homebridge-netatmo-temperature 1.0.0

package/config.schema.json

@@ -0,0 +1,40 @@
+{
+  "pluginAlias": "NetatmoTemperature",
+  "pluginType": "platform",
+  "singular": true,
+  "headerDisplay": "Netatmo Weather Station temperatures for HomeKit. Get your credentials at https://dev.netatmo.com",
+  "schema": {
+    "type": "object",
+    "properties": {
+      "clientId": {
+        "title": "Client ID",
+        "type": "string",
+        "required": true,
+        "description": "Client ID from your Netatmo app at dev.netatmo.com"
+      },
+      "clientSecret": {
+        "title": "Client Secret",
+        "type": "string",
+        "required": true,
+        "description": "Client Secret from your Netatmo app at dev.netatmo.com"
+      },
+      "refreshToken": {
+        "title": "Refresh Token",
+        "type": "string",
+        "description": "OAuth2 Refresh Token from Netatmo (auto-renews access tokens)"
+      },
+      "token": {
+        "title": "Access Token (optional)",
+        "type": "string",
+        "description": "Direct access token - use if you don't have a refresh token yet"
+      },
+      "pollingInterval": {
+        "title": "Polling Interval (seconds)",
+        "type": "integer",
+        "default": 300,
+        "minimum": 60,
+        "description": "How often to refresh temperature data (default: 300s = 5 min)"
+      }
+    }
+  }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (api: API) => void;
+export = _default;

package/dist/index.js

@@ -0,0 +1,4 @@
+"use strict";
+module.exports = (api) => {
+    api.registerPlatform(PLATFORM_NAME, NetatmoPlatform);
+};

package/dist/netatmoApi.d.ts

@@ -0,0 +1,24 @@
+export interface NetatmoModule {
+    id: string;
+    name: string;
+    type: string;
+    temperature: number | null;
+    humidity: number | null;
+    co2?: number | null;
+    pressure?: number | null;
+    noise?: number | null;
+    battery?: number | null;
+    reachable: boolean;
+}
+export declare class NetatmoApi {
+    private client;
+    private accessToken;
+    private refreshToken;
+    private clientId;
+    private clientSecret;
+    private tokenExpiry;
+    private log;
+    constructor(clientId: string, clientSecret: string, refreshToken: string, log: Logger, directToken?: string);
+    authenticate(): Promise<void>;
+    getStationData(): Promise<NetatmoModule[]>;
+}

package/dist/netatmoApi.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetatmoApi = void 0;
+const axios_1 = __importDefault(require("axios"));
+class NetatmoApi {
+    constructor(clientId, clientSecret, refreshToken, log, directToken) {
+        this.tokenExpiry = 0;
+        this.clientId = clientId;
+        this.clientSecret = clientSecret;
+        this.refreshToken = refreshToken;
+        this.log = log;
+        this.accessToken = directToken || '';
+        this.client = axios_1.default.create({
+            baseURL: 'https://api.netatmo.com',
+            timeout: 30000,
+        });
+    }
+    async authenticate() {
+        // If we have a direct token and it hasn't expired, use it
+        if (this.accessToken && Date.now() < this.tokenExpiry) {
+            return;
+        }
+        // If we have a direct token but no expiry set, assume valid for 3 hours
+        if (this.accessToken && this.tokenExpiry === 0) {
+            this.tokenExpiry = Date.now() + 10800000;
+            this.client.defaults.headers.common['Authorization'] = 'Bearer ' + this.accessToken;
+            this.log.info('Netatmo: using configured access token');
+            return;
+        }
+        // Use refresh_token to get a new access_token
+        if (!this.refreshToken) {
+            throw new Error('No refresh token configured. Please provide a refresh_token or access token.');
+        }
+        try {
+            this.log.info('Netatmo: refreshing access token...');
+            const res = await this.client.post('/oauth2/token', new URLSearchParams({
+                grant_type: 'refresh_token',
+                refresh_token: this.refreshToken,
+                client_id: this.clientId,
+                client_secret: this.clientSecret,
+            }).toString(), {
+                headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            });
+            this.accessToken = res.data.access_token;
+            this.refreshToken = res.data.refresh_token || this.refreshToken;
+            this.tokenExpiry = Date.now() + (res.data.expires_in || 10800) * 1000;
+            this.client.defaults.headers.common['Authorization'] = 'Bearer ' + this.accessToken;
+            this.log.info('Netatmo: authenticated successfully (token valid for', Math.round((res.data.expires_in || 10800) / 3600), 'hours)');
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            this.log.error('Netatmo: authentication failed -', msg);
+            throw e;
+        }
+    }
+    async getStationData() {
+        await this.authenticate();
+        try {
+            const res = await this.client.get('/api/getstationsdata', {
+                headers: { 'Authorization': 'Bearer ' + this.accessToken },
+            });
+            const devices = res.data?.body?.devices;
+            if (!devices || devices.length === 0) {
+                this.log.warn('Netatmo: no weather stations found');
+                return [];
+            }
+            const modules = [];
+            for (const device of devices) {
+                // Main indoor station
+                const mainData = device.dashboard_data || {};
+                modules.push({
+                    id: device._id,
+                    name: device.station_name || device.module_name || 'Indoor',
+                    type: device.type || 'NAMain',
+                    temperature: mainData.Temperature ?? null,
+                    humidity: mainData.Humidity ?? null,
+                    co2: mainData.CO2 ?? null,
+                    pressure: mainData.Pressure ?? null,
+                    noise: mainData.Noise ?? null,
+                    battery: null, // main station is plugged in
+                    reachable: true,
+                });
+                // Sub-modules (outdoor, extra indoor, rain, wind)
+                if (device.modules) {
+                    for (const mod of device.modules) {
+                        const modData = mod.dashboard_data || {};
+                        // Only include modules that have temperature
+                        if (modData.Temperature !== undefined) {
+                            modules.push({
+                                id: mod._id,
+                                name: mod.module_name || mod.type || 'Module',
+                                type: mod.type || 'unknown',
+                                temperature: modData.Temperature ?? null,
+                                humidity: modData.Humidity ?? null,
+                                co2: modData.CO2 ?? null,
+                                pressure: null,
+                                noise: null,
+                                battery: mod.battery_percent ?? null,
+                                reachable: mod.reachable ?? false,
+                            });
+                        }
+                    }
+                }
+            }
+            this.log.info('Netatmo: found', modules.length, 'temperature modules');
+            return modules;
+        }
+        catch (e) {
+            // If 403/401, try to re-authenticate
+            if (axios_1.default.isAxiosError(e) && (e.response?.status === 401 || e.response?.status === 403)) {
+                this.log.warn('Netatmo: token expired, re-authenticating...');
+                this.tokenExpiry = 0;
+                this.accessToken = '';
+                await this.authenticate();
+                return this.getStationData();
+            }
+            const msg = e instanceof Error ? e.message : String(e);
+            this.log.error('Netatmo: failed to get station data -', msg);
+            throw e;
+        }
+    }
+}
+exports.NetatmoApi = NetatmoApi;

package/dist/platform.d.ts

@@ -0,0 +1,16 @@
+export declare class NetatmoPlatform implements DynamicPlatformPlugin {
+    readonly log: Logger;
+    readonly config: PlatformConfig;
+    readonly api: API;
+    readonly Service: typeof Service;
+    readonly Characteristic: typeof Characteristic;
+    private netatmoApi;
+    private cachedAccessories;
+    private pollingInterval;
+    private modules;
+    constructor(log: Logger, config: PlatformConfig, api: API);
+    configureAccessory(accessory: PlatformAccessory): void;
+    onReady(): Promise<void>;
+    registerAccessories(modules: NetatmoModule[]): void;
+    poll(): Promise<void>;
+}

package/dist/platform.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetatmoPlatform = void 0;
+class NetatmoPlatform {
+    constructor(log, config, api) {
+        this.log = log;
+        this.config = config;
+        this.api = api;
+        this.Service = this.api.hap.Service;
+        this.Characteristic = this.api.hap.Characteristic;
+        this.cachedAccessories = [];
+        this.modules = new Map();
+        this.pollingInterval = (config.pollingInterval || 300) * 1000; // default 5 min
+        this.api.on('didFinishLaunching', () => this.onReady());
+    }
+    configureAccessory(accessory) {
+        this.log.info('Restoring cached accessory:', accessory.displayName);
+        this.cachedAccessories.push(accessory);
+    }
+    async onReady() {
+        // Validate config
+        if (!this.config.refreshToken && !this.config.token) {
+            this.log.error('Missing refresh_token or token in config. Please configure Netatmo credentials.');
+            return;
+        }
+        this.netatmoApi = new NetatmoApi(this.config.clientId || '', this.config.clientSecret || '', this.config.refreshToken || '', this.log, this.config.token || '');
+        try {
+            await this.netatmoApi.authenticate();
+        }
+        catch {
+            this.log.error('Failed to connect to Netatmo API');
+            return;
+        }
+        // Get initial data and register accessories
+        try {
+            const modules = await this.netatmoApi.getStationData();
+            this.registerAccessories(modules);
+            this.log.info('Netatmo: total sensors registered:', modules.length);
+        }
+        catch (e) {
+            this.log.error('Failed to get initial Netatmo data');
+            return;
+        }
+        // Start polling
+        setInterval(() => this.poll(), this.pollingInterval);
+    }
+    registerAccessories(modules) {
+        const newAccessories = [];
+        for (const mod of modules) {
+            const uuid = this.api.hap.uuid.generate(PLUGIN_NAME + '-' + mod.id);
+            let accessory = this.cachedAccessories.find(a => a.UUID === uuid);
+            if (!accessory) {
+                const displayName = mod.name;
+                accessory = new this.api.platformAccessory(displayName, uuid);
+                newAccessories.push(accessory);
+                this.log.info('Adding new accessory:', displayName);
+            }
+            // Setup TemperatureSensor service
+            let tempService = accessory.getService(this.Service.TemperatureSensor);
+            if (!tempService) {
+                tempService = accessory.addService(this.Service.TemperatureSensor, mod.name);
+            }
+            // Set initial temperature
+            if (mod.temperature !== null) {
+                tempService.getCharacteristic(this.Characteristic.CurrentTemperature)
+                    .updateValue(mod.temperature);
+            }
+            // Setup HumiditySensor service if humidity data available
+            if (mod.humidity !== null) {
+                let humService = accessory.getService(this.Service.HumiditySensor);
+                if (!humService) {
+                    humService = accessory.addService(this.Service.HumiditySensor, mod.name + ' Humidity');
+                }
+                humService.getCharacteristic(this.Characteristic.CurrentRelativeHumidity)
+                    .updateValue(mod.humidity);
+            }
+            // Set accessory info
+            const infoService = accessory.getService(this.Service.AccessoryInformation);
+            if (infoService) {
+                infoService
+                    .setCharacteristic(this.Characteristic.Manufacturer, 'Netatmo')
+                    .setCharacteristic(this.Characteristic.Model, mod.type)
+                    .setCharacteristic(this.Characteristic.SerialNumber, mod.id);
+            }
+            this.modules.set(mod.id, { accessory, data: mod });
+        }
+        if (newAccessories.length > 0) {
+            this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, newAccessories);
+        }
+        // Remove orphaned accessories
+        const activeUUIDs = new Set(modules.map(m => this.api.hap.uuid.generate(PLUGIN_NAME + '-' + m.id)));
+        const orphans = this.cachedAccessories.filter(a => !activeUUIDs.has(a.UUID));
+        if (orphans.length > 0) {
+            this.log.info('Removing', orphans.length, 'orphaned accessories');
+            this.api.unregisterPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, orphans);
+        }
+    }
+    async poll() {
+        try {
+            const modules = await this.netatmoApi.getStationData();
+            for (const mod of modules) {
+                const entry = this.modules.get(mod.id);
+                if (!entry) {
+                    continue;
+                }
+                const { accessory } = entry;
+                // Update temperature
+                if (mod.temperature !== null) {
+                    const tempService = accessory.getService(this.Service.TemperatureSensor);
+                    if (tempService) {
+                        tempService.getCharacteristic(this.Characteristic.CurrentTemperature)
+                            .updateValue(mod.temperature);
+                    }
+                }
+                // Update humidity
+                if (mod.humidity !== null) {
+                    const humService = accessory.getService(this.Service.HumiditySensor);
+                    if (humService) {
+                        humService.getCharacteristic(this.Characteristic.CurrentRelativeHumidity)
+                            .updateValue(mod.humidity);
+                    }
+                }
+                entry.data = mod;
+            }
+            // Log summary
+            const summary = modules.map(m => m.name + '=' + (m.temperature !== null ? m.temperature + '°C' : 'N/A') +
+                (m.humidity !== null ? ' ' + m.humidity + '%' : '')).join(', ');
+            this.log.info('Netatmo poll:', summary);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            this.log.error('Netatmo poll failed:', msg);
+        }
+    }
+}
+exports.NetatmoPlatform = NetatmoPlatform;

package/dist/settings.d.ts

@@ -0,0 +1,2 @@
+export declare const PLATFORM_NAME = "NetatmoTemperature";
+export declare const PLUGIN_NAME = "homebridge-netatmo-temperature";

package/dist/settings.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLUGIN_NAME = exports.PLATFORM_NAME = void 0;
+exports.PLATFORM_NAME = 'NetatmoTemperature';
+exports.PLUGIN_NAME = 'homebridge-netatmo-temperature';

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "homebridge-netatmo-temperature",
+  "version": "1.0.0",
+  "description": "Homebridge plugin for Netatmo weather station temperatures in Apple HomeKit",
+  "license": "Apache-2.0",
+  "author": "trama2000",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/trama2000/homebridge-netatmo-temperature.git"
+  },
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "echo skip"
+  },
+  "keywords": [
+    "homebridge-plugin",
+    "netatmo",
+    "temperature",
+    "weather",
+    "homekit"
+  ],
+  "engines": {
+    "homebridge": ">=1.6.0",
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "axios": "^1.6.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "homebridge": "^1.8.0",
+    "typescript": "^5.0.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export = (api: API) => {
+  api.registerPlatform(PLATFORM_NAME, NetatmoPlatform);
+};

package/src/netatmoApi.ts

@@ -0,0 +1,156 @@
+import axios, { AxiosInstance } from 'axios';
+export interface NetatmoModule {
+  id: string;
+  name: string;
+  type: string; // NAMain, NAModule1 (outdoor), NAModule4 (indoor extra)
+  temperature: number | null;
+  humidity: number | null;
+  co2?: number | null;
+  pressure?: number | null;
+  noise?: number | null;
+  battery?: number | null;
+  reachable: boolean;
+}
+
+export class NetatmoApi {
+  private client: AxiosInstance;
+  private accessToken: string;
+  private refreshToken: string;
+  private clientId: string;
+  private clientSecret: string;
+  private tokenExpiry = 0;
+  private log: Logger;
+
+  constructor(
+    clientId: string,
+    clientSecret: string,
+    refreshToken: string,
+    log: Logger,
+    directToken?: string,
+  ) {
+    this.clientId = clientId;
+    this.clientSecret = clientSecret;
+    this.refreshToken = refreshToken;
+    this.log = log;
+    this.accessToken = directToken || '';
+
+    this.client = axios.create({
+      baseURL: 'https://api.netatmo.com',
+      timeout: 30000,
+    });
+  }
+
+  async authenticate(): Promise<void> {
+    // If we have a direct token and it hasn't expired, use it
+    if (this.accessToken && Date.now() < this.tokenExpiry) {
+      return;
+    }
+
+    // If we have a direct token but no expiry set, assume valid for 3 hours
+    if (this.accessToken && this.tokenExpiry === 0) {
+      this.tokenExpiry = Date.now() + 10800000;
+      this.client.defaults.headers.common['Authorization'] = 'Bearer ' + this.accessToken;
+      this.log.info('Netatmo: using configured access token');
+      return;
+    }
+
+    // Use refresh_token to get a new access_token
+    if (!this.refreshToken) {
+      throw new Error('No refresh token configured. Please provide a refresh_token or access token.');
+    }
+
+    try {
+      this.log.info('Netatmo: refreshing access token...');
+      const res = await this.client.post('/oauth2/token', new URLSearchParams({
+        grant_type: 'refresh_token',
+        refresh_token: this.refreshToken,
+        client_id: this.clientId,
+        client_secret: this.clientSecret,
+      }).toString(), {
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      });
+
+      this.accessToken = res.data.access_token;
+      this.refreshToken = res.data.refresh_token || this.refreshToken;
+      this.tokenExpiry = Date.now() + (res.data.expires_in || 10800) * 1000;
+      this.client.defaults.headers.common['Authorization'] = 'Bearer ' + this.accessToken;
+      this.log.info('Netatmo: authenticated successfully (token valid for', Math.round((res.data.expires_in || 10800) / 3600), 'hours)');
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      this.log.error('Netatmo: authentication failed -', msg);
+      throw e;
+    }
+  }
+
+  async getStationData(): Promise<NetatmoModule[]> {
+    await this.authenticate();
+
+    try {
+      const res = await this.client.get('/api/getstationsdata', {
+        headers: { 'Authorization': 'Bearer ' + this.accessToken },
+      });
+
+      const devices = res.data?.body?.devices;
+      if (!devices || devices.length === 0) {
+        this.log.warn('Netatmo: no weather stations found');
+        return [];
+      }
+
+      const modules: NetatmoModule[] = [];
+
+      for (const device of devices) {
+        // Main indoor station
+        const mainData = device.dashboard_data || {};
+        modules.push({
+          id: device._id,
+          name: device.station_name || device.module_name || 'Indoor',
+          type: device.type || 'NAMain',
+          temperature: mainData.Temperature ?? null,
+          humidity: mainData.Humidity ?? null,
+          co2: mainData.CO2 ?? null,
+          pressure: mainData.Pressure ?? null,
+          noise: mainData.Noise ?? null,
+          battery: null, // main station is plugged in
+          reachable: true,
+        });
+
+        // Sub-modules (outdoor, extra indoor, rain, wind)
+        if (device.modules) {
+          for (const mod of device.modules) {
+            const modData = mod.dashboard_data || {};
+            // Only include modules that have temperature
+            if (modData.Temperature !== undefined) {
+              modules.push({
+                id: mod._id,
+                name: mod.module_name || mod.type || 'Module',
+                type: mod.type || 'unknown',
+                temperature: modData.Temperature ?? null,
+                humidity: modData.Humidity ?? null,
+                co2: modData.CO2 ?? null,
+                pressure: null,
+                noise: null,
+                battery: mod.battery_percent ?? null,
+                reachable: mod.reachable ?? false,
+              });
+            }
+          }
+        }
+      }
+
+      this.log.info('Netatmo: found', modules.length, 'temperature modules');
+      return modules;
+    } catch (e: unknown) {
+      // If 403/401, try to re-authenticate
+      if (axios.isAxiosError(e) && (e.response?.status === 401 || e.response?.status === 403)) {
+        this.log.warn('Netatmo: token expired, re-authenticating...');
+        this.tokenExpiry = 0;
+        this.accessToken = '';
+        await this.authenticate();
+        return this.getStationData();
+      }
+      const msg = e instanceof Error ? e.message : String(e);
+      this.log.error('Netatmo: failed to get station data -', msg);
+      throw e;
+    }
+  }
+}

package/src/platform.ts

@@ -0,0 +1,166 @@
+export class NetatmoPlatform implements DynamicPlatformPlugin {
+  public readonly Service: typeof Service = this.api.hap.Service;
+  public readonly Characteristic: typeof Characteristic = this.api.hap.Characteristic;
+
+  private netatmoApi!: NetatmoApi;
+  private cachedAccessories: PlatformAccessory[] = [];
+  private pollingInterval: number;
+  private modules: Map<string, { accessory: PlatformAccessory; data: NetatmoModule }> = new Map();
+
+  constructor(
+    public readonly log: Logger,
+    public readonly config: PlatformConfig,
+    public readonly api: API,
+  ) {
+    this.pollingInterval = (config.pollingInterval || 300) * 1000; // default 5 min
+    this.api.on('didFinishLaunching', () => this.onReady());
+  }
+
+  configureAccessory(accessory: PlatformAccessory) {
+    this.log.info('Restoring cached accessory:', accessory.displayName);
+    this.cachedAccessories.push(accessory);
+  }
+
+  async onReady() {
+    // Validate config
+    if (!this.config.refreshToken && !this.config.token) {
+      this.log.error('Missing refresh_token or token in config. Please configure Netatmo credentials.');
+      return;
+    }
+
+    this.netatmoApi = new NetatmoApi(
+      this.config.clientId || '',
+      this.config.clientSecret || '',
+      this.config.refreshToken || '',
+      this.log,
+      this.config.token || '',
+    );
+
+    try {
+      await this.netatmoApi.authenticate();
+    } catch {
+      this.log.error('Failed to connect to Netatmo API');
+      return;
+    }
+
+    // Get initial data and register accessories
+    try {
+      const modules = await this.netatmoApi.getStationData();
+      this.registerAccessories(modules);
+      this.log.info('Netatmo: total sensors registered:', modules.length);
+    } catch (e) {
+      this.log.error('Failed to get initial Netatmo data');
+      return;
+    }
+
+    // Start polling
+    setInterval(() => this.poll(), this.pollingInterval);
+  }
+
+  registerAccessories(modules: NetatmoModule[]) {
+    const newAccessories: PlatformAccessory[] = [];
+
+    for (const mod of modules) {
+      const uuid = this.api.hap.uuid.generate(PLUGIN_NAME + '-' + mod.id);
+      let accessory = this.cachedAccessories.find(a => a.UUID === uuid);
+
+      if (!accessory) {
+        const displayName = mod.name;
+        accessory = new this.api.platformAccessory(displayName, uuid);
+        newAccessories.push(accessory);
+        this.log.info('Adding new accessory:', displayName);
+      }
+
+      // Setup TemperatureSensor service
+      let tempService = accessory.getService(this.Service.TemperatureSensor);
+      if (!tempService) {
+        tempService = accessory.addService(this.Service.TemperatureSensor, mod.name);
+      }
+
+      // Set initial temperature
+      if (mod.temperature !== null) {
+        tempService.getCharacteristic(this.Characteristic.CurrentTemperature)
+          .updateValue(mod.temperature);
+      }
+
+      // Setup HumiditySensor service if humidity data available
+      if (mod.humidity !== null) {
+        let humService = accessory.getService(this.Service.HumiditySensor);
+        if (!humService) {
+          humService = accessory.addService(this.Service.HumiditySensor, mod.name + ' Humidity');
+        }
+        humService.getCharacteristic(this.Characteristic.CurrentRelativeHumidity)
+          .updateValue(mod.humidity);
+      }
+
+      // Set accessory info
+      const infoService = accessory.getService(this.Service.AccessoryInformation);
+      if (infoService) {
+        infoService
+          .setCharacteristic(this.Characteristic.Manufacturer, 'Netatmo')
+          .setCharacteristic(this.Characteristic.Model, mod.type)
+          .setCharacteristic(this.Characteristic.SerialNumber, mod.id);
+      }
+
+      this.modules.set(mod.id, { accessory, data: mod });
+    }
+
+    if (newAccessories.length > 0) {
+      this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, newAccessories);
+    }
+
+    // Remove orphaned accessories
+    const activeUUIDs = new Set(modules.map(m => this.api.hap.uuid.generate(PLUGIN_NAME + '-' + m.id)));
+    const orphans = this.cachedAccessories.filter(a => !activeUUIDs.has(a.UUID));
+    if (orphans.length > 0) {
+      this.log.info('Removing', orphans.length, 'orphaned accessories');
+      this.api.unregisterPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, orphans);
+    }
+  }
+
+  async poll() {
+    try {
+      const modules = await this.netatmoApi.getStationData();
+
+      for (const mod of modules) {
+        const entry = this.modules.get(mod.id);
+        if (!entry) {
+          continue;
+        }
+
+        const { accessory } = entry;
+
+        // Update temperature
+        if (mod.temperature !== null) {
+          const tempService = accessory.getService(this.Service.TemperatureSensor);
+          if (tempService) {
+            tempService.getCharacteristic(this.Characteristic.CurrentTemperature)
+              .updateValue(mod.temperature);
+          }
+        }
+
+        // Update humidity
+        if (mod.humidity !== null) {
+          const humService = accessory.getService(this.Service.HumiditySensor);
+          if (humService) {
+            humService.getCharacteristic(this.Characteristic.CurrentRelativeHumidity)
+              .updateValue(mod.humidity);
+          }
+        }
+
+        entry.data = mod;
+      }
+
+      // Log summary
+      const summary = modules.map(m =>
+        m.name + '=' + (m.temperature !== null ? m.temperature + '°C' : 'N/A') +
+        (m.humidity !== null ? ' ' + m.humidity + '%' : '')
+      ).join(', ');
+      this.log.info('Netatmo poll:', summary);
+
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      this.log.error('Netatmo poll failed:', msg);
+    }
+  }
+}

package/src/settings.ts

@@ -0,0 +1,2 @@
+export const PLATFORM_NAME = 'NetatmoTemperature';
+export const PLUGIN_NAME = 'homebridge-netatmo-temperature';

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": [
+      "ES2020"
+    ],
+    "declaration": true,
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": [
+    "src/"
+  ]
+}