@mp-consulting/homebridge-daikin-cloud 1.5.2 → 1.6.0

package/dist/src/platform.d.ts

@@ -1,41 +1,88 @@
 import type { API, Characteristic, DynamicPlatformPlugin, Logger, PlatformAccessory, PlatformConfig, Service } from 'homebridge';
 import type { DaikinCloudDevice } from './api';
 import { DaikinCloudController } from './api';
+import { ConfigManager } from './config/config-manager';
+/** Safety-net poll interval while the WebSocket is delivering push updates */
+export declare const WEBSOCKET_SAFETY_POLL_INTERVAL_MS: number;
+/** Minimum poll interval once the daily quota is nearly exhausted */
+export declare const LOW_QUOTA_POLL_INTERVAL_MS: number;
+/** Upper bound of the failure backoff, as a multiple of the base interval */
+export declare const MAX_POLL_BACKOFF_MULTIPLIER = 4;
+export interface PollIntervalInput {
+    configuredMs: number;
+    webSocketConnected: boolean;
+    consecutiveFailures: number;
+    remainingDay?: number;
+}
+/**
+ * Compute the delay until the next periodic poll:
+ * - WebSocket connected: push updates arrive anyway, poll only as a safety net
+ * - consecutive failures: exponential backoff, capped at MAX_POLL_BACKOFF_MULTIPLIER
+ * - daily quota nearly exhausted: stretch to LOW_QUOTA_POLL_INTERVAL_MS
+ */
+export declare function computePollInterval(input: PollIntervalInput): number;
 export type DaikinCloudAccessoryContext = {
     device: DaikinCloudDevice;
 };
 export declare class DaikinCloudPlatform implements DynamicPlatformPlugin {
     readonly log: Logger;
-    readonly config: PlatformConfig;
     readonly api: API;
     readonly Service: typeof Service;
     readonly Characteristic: typeof Characteristic;
     readonly accessories: PlatformAccessory<DaikinCloudAccessoryContext>[];
     readonly storagePath: string;
+    /** Single source of truth for the plugin configuration: read config only through this */
+    readonly configManager: ConfigManager;
     controller: DaikinCloudController | undefined;
     readonly updateIntervalDelay: number;
-    private updateInterval;
+    private pollTimer;
     private forceUpdateTimeout;
+    private inFlightUpdate;
+    private pollingStarted;
+    private isShuttingDown;
+    private consecutivePollFailures;
+    private remainingDay;
+    private webSocketHasConnected;
+    private pendingRateLimitStatus;
+    private rateLimitWriteTimer;
+    private lastRateLimitWriteAt;
     private readonly accessoryFactory;
-    private readonly updateMapper;
     private readonly authMode;
     private readonly deviceListeners;
     constructor(log: Logger, config: PlatformConfig, api: API);
+    private registerControllerListeners;
     configureAccessory(accessory: PlatformAccessory): void;
     private discoverDevices;
     private createDevices;
     private removeDeviceListener;
     registerDeviceListener(accessory: PlatformAccessory<DaikinCloudAccessoryContext>, listener: () => void): void;
+    /**
+     * Fetch fresh device data. Overlapping callers (periodic poll, forced update,
+     * WebSocket reconnect catch-up) share a single in-flight request.
+     */
     private updateDevices;
+    /**
+     * Poll now, then schedule the next periodic poll.
+     */
+    private pollNow;
     forceUpdateDevices(delay?: number): void;
+    /**
+     * (Re)schedule the next periodic poll. Always replaces any previously
+     * scheduled poll, so there is never more than one pending.
+     */
     private startUpdateDevicesInterval;
+    private stopPolling;
+    private getPollInterval;
+    private isWebSocketConnected;
+    private onWebSocketConnected;
+    private onRateLimitStatus;
+    /**
+     * Persist the latest rate-limit headers for the settings UI (throttled,
+     * best effort: failures are logged at debug level and never thrown).
+     */
+    private saveRateLimitStatus;
+    private flushRateLimitStatus;
     private enableWebSocket;
-    private isExcludedDevice;
-    private getPrivacyFriendlyConfig;
     private onInvalidGrantError;
-    /**
-       * Handle WebSocket device updates by pushing updated values to HomeKit
-       */
-    private handleWebSocketDeviceUpdate;
 }
 //# sourceMappingURL=platform.d.ts.map

package/dist/src/platform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"platform.d.ts","sourceRoot":"","sources":["../../src/platform.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,EAAE,iBAAiB,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AASjI,OAAO,KAAK,EAAE,iBAAiB,EAA0B,MAAM,OAAO,CAAC;AACvE,OAAO,EAAmB,qBAAqB,EAAE,MAAM,OAAO,CAAC;AAa/D,MAAM,MAAM,2BAA2B,GAAG;IACtC,MAAM,EAAE,iBAAiB,CAAC;CAC7B,CAAC;AAEF,qBAAa,mBAAoB,YAAW,qBAAqB;aAkBzC,GAAG,EAAE,MAAM;aACX,MAAM,EAAE,cAAc;aACtB,GAAG,EAAE,GAAG;IAnB9B,SAAgB,OAAO,EAAE,OAAO,OAAO,CAAC;IACxC,SAAgB,cAAc,EAAE,OAAO,cAAc,CAAC;IAEtD,SAAgB,WAAW,EAAE,iBAAiB,CAAC,2BAA2B,CAAC,EAAE,CAAM;IAEnF,SAAgB,WAAW,EAAE,MAAM,CAAM;IAClC,UAAU,EAAE,qBAAqB,GAAG,SAAS,CAAC;IAErD,SAAgB,mBAAmB,EAAE,MAAM,CAAC;IAC5C,OAAO,CAAC,cAAc,CAA6B;IACnD,OAAO,CAAC,kBAAkB,CAA6B;IACvD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAmB;IACpD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAe;IAC5C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAoC;IAC7D,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAiC;gBAG3C,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,cAAc,EACtB,GAAG,EAAE,GAAG;IAmLvB,kBAAkB,CAAC,SAAS,EAAE,iBAAiB;YAKxC,eAAe;IAgB7B,OAAO,CAAC,aAAa;IAsDrB,OAAO,CAAC,oBAAoB;IAQ5B,sBAAsB,CAAC,SAAS,EAAE,iBAAiB,CAAC,2BAA2B,CAAC,EAAE,QAAQ,EAAE,MAAM,IAAI;YAIxF,aAAa;IAW3B,kBAAkB,CAAC,KAAK,GAAE,MAAmF;IA0B7G,OAAO,CAAC,0BAA0B;YAWpB,eAAe;IAc7B,OAAO,CAAC,gBAAgB;IAIxB,OAAO,CAAC,wBAAwB;IAchC,OAAO,CAAC,mBAAmB;IAU3B;;SAEK;IACL,OAAO,CAAC,2BAA2B;CAuBpC"}
+{"version":3,"file":"platform.d.ts","sourceRoot":"","sources":["../../src/platform.ts"],"names":[],"mappings":"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"}

package/dist/src/platform.js

@@ -3,56 +3,100 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DaikinCloudPlatform = void 0;
+exports.DaikinCloudPlatform = exports.MAX_POLL_BACKOFF_MULTIPLIER = exports.LOW_QUOTA_POLL_INTERVAL_MS = exports.WEBSOCKET_SAFETY_POLL_INTERVAL_MS = void 0;
+exports.computePollInterval = computePollInterval;
 const settings_1 = require("./settings");
 const device_1 = require("./device");
 const node_path_1 = require("node:path");
+const node_util_1 = require("node:util");
 const strings_1 = require("./utils/strings");
+const errors_1 = require("./utils/errors");
 const node_fs_1 = __importDefault(require("node:fs"));
 const api_1 = require("./api");
 const http_transport_1 = require("./api/http-transport");
-const update_mapper_1 = require("./utils/update-mapper");
 const config_manager_1 = require("./config/config-manager");
 const constants_1 = require("./constants");
+/** Safety-net poll interval while the WebSocket is delivering push updates */
+exports.WEBSOCKET_SAFETY_POLL_INTERVAL_MS = 60 * constants_1.ONE_MINUTE_MS;
+/** Minimum poll interval once the daily quota is nearly exhausted */
+exports.LOW_QUOTA_POLL_INTERVAL_MS = 60 * constants_1.ONE_MINUTE_MS;
+/** Upper bound of the failure backoff, as a multiple of the base interval */
+exports.MAX_POLL_BACKOFF_MULTIPLIER = 4;
+/** Minimum time between two writes of the rate-limit status file */
+const RATE_LIMIT_FILE_MIN_WRITE_INTERVAL_MS = 5 * constants_1.ONE_SECOND_MS;
+/**
+ * Compute the delay until the next periodic poll:
+ * - WebSocket connected: push updates arrive anyway, poll only as a safety net
+ * - consecutive failures: exponential backoff, capped at MAX_POLL_BACKOFF_MULTIPLIER
+ * - daily quota nearly exhausted: stretch to LOW_QUOTA_POLL_INTERVAL_MS
+ */
+function computePollInterval(input) {
+    let interval = input.configuredMs;
+    if (input.webSocketConnected) {
+        interval = Math.max(interval, exports.WEBSOCKET_SAFETY_POLL_INTERVAL_MS);
+    }
+    if (input.consecutiveFailures > 0) {
+        interval *= Math.min(2 ** input.consecutiveFailures, exports.MAX_POLL_BACKOFF_MULTIPLIER);
+    }
+    if (input.remainingDay !== undefined && input.remainingDay <= constants_1.RATE_LIMIT_WARNING_THRESHOLD) {
+        interval = Math.max(interval, exports.LOW_QUOTA_POLL_INTERVAL_MS);
+    }
+    return interval;
+}
+/**
+ * Wrap an expensive serialisation so it only runs if the logger actually
+ * formats the parameter (Homebridge skips formatting when debug is off).
+ */
+function lazyJson(producer, space) {
+    return { [node_util_1.inspect.custom]: () => JSON.stringify(producer(), null, space) };
+}
 class DaikinCloudPlatform {
     log;
-    config;
     api;
     Service;
     Characteristic;
     accessories = [];
     storagePath = '';
+    /** Single source of truth for the plugin configuration: read config only through this */
+    configManager;
     controller;
     updateIntervalDelay;
-    updateInterval;
+    pollTimer;
     forceUpdateTimeout;
+    inFlightUpdate;
+    pollingStarted = false;
+    isShuttingDown = false;
+    consecutivePollFailures = 0;
+    remainingDay;
+    webSocketHasConnected = false;
+    pendingRateLimitStatus;
+    rateLimitWriteTimer;
+    lastRateLimitWriteAt = 0;
     accessoryFactory;
-    updateMapper;
     authMode;
     deviceListeners = new Map();
     constructor(log, config, api) {
         this.log = log;
-        this.config = config;
         this.api = api;
+        this.configManager = new config_manager_1.ConfigManager(config);
+        const configManager = this.configManager;
         this.log.info('--- Daikin info for debugging reasons (enable Debug Mode for more logs) ---');
-        this.log.debug('[Platform] Initializing platform:', this.config.name);
+        this.log.debug('[Platform] Initializing platform:', configManager.getName());
         this.Service = this.api.hap.Service;
         this.Characteristic = this.api.hap.Characteristic;
         this.storagePath = api.user.storagePath();
-        this.updateIntervalDelay = constants_1.ONE_MINUTE_MS * (this.config.updateIntervalInMinutes || constants_1.DEFAULT_UPDATE_INTERVAL_MINUTES);
+        this.updateIntervalDelay = configManager.getUpdateIntervalMs();
         this.accessoryFactory = new device_1.AccessoryFactory(this);
-        this.updateMapper = new update_mapper_1.UpdateMapper(this.log, this.Service, this.Characteristic);
         // Determine authentication mode
-        this.authMode = this.config.authMode === 'mobile_app' ? 'mobile_app' : 'developer_portal';
+        this.authMode = configManager.getAuthMode();
         this.log.info(`[Config] Authentication mode: ${this.authMode}`);
         // Select the HTTP transport (env var DAIKIN_HTTP_TRANSPORT wins over config)
-        (0, http_transport_1.configureHttpTransport)(this.config.httpTransport);
+        (0, http_transport_1.configureHttpTransport)(configManager.getHttpTransport());
         if ((0, http_transport_1.getHttpTransportMode)() === 'curl') {
             this.log.info('[Config] HTTP transport: curl subprocess (WAF fingerprint workaround). '
                 + 'Note: WebSocket connections still use Node TLS — disable WebSocket if it cannot connect.');
         }
         // Validate configuration
-        const configManager = new config_manager_1.ConfigManager(this.config);
         const validation = configManager.validate();
         for (const warning of validation.warnings) {
             this.log.warn(`[Config] ${warning}`);
@@ -69,32 +113,22 @@ class DaikinCloudPlatform {
             }
         }
         else {
-            if (!this.config.clientId || !this.config.clientSecret) {
+            if (!configManager.hasDeveloperCredentials()) {
                 this.log.warn('[Config] Client ID and/or Client Secret not configured.');
                 this.log.warn('[Config] Please configure the plugin using the Homebridge UI.');
                 this.log.info('--------------- End Daikin info for debugging reasons --------------------');
                 return;
             }
         }
+        // Credentials are present: the remaining errors (e.g. a localhost callback
+        // address or an invalid port) do not stop startup, but must be visible.
+        for (const error of validation.errors) {
+            this.log.error(`[Config] ${error}`);
+        }
         // Use different token file for mobile auth to avoid conflicts
-        const tokenFileName = this.authMode === 'mobile_app'
-            ? '.daikin-mobile-tokenset'
-            : '.daikin-controller-cloud-tokenset';
-        const tokenFilePath = (0, node_path_1.resolve)(this.storagePath, tokenFileName);
-        const daikinCloudControllerConfig = {
-            authMode: this.authMode,
-            tokenFilePath,
-            // Developer Portal fields
-            clientId: this.config.clientId,
-            clientSecret: this.config.clientSecret,
-            callbackServerExternalAddress: this.config.callbackServerExternalAddress,
-            callbackServerPort: this.config.callbackServerPort || 8582,
-            oidcCallbackServerBindAddr: this.config.oidcCallbackServerBindAddr,
-            // Mobile App fields
-            email: configManager.getMobileEmail(),
-            password: configManager.getMobilePassword(),
-        };
-        this.log.debug('[Config] Homebridge config', this.getPrivacyFriendlyConfig(this.config));
+        const tokenFilePath = (0, node_path_1.resolve)(this.storagePath, constants_1.TOKEN_FILES[this.authMode]);
+        const daikinCloudControllerConfig = configManager.getControllerConfig(tokenFilePath);
+        this.log.debug('[Config] Homebridge config', configManager.getRedactedConfig());
         node_fs_1.default.stat(tokenFilePath, (err, stats) => {
             if (err) {
                 this.log.debug('[Config] Token file does NOT exist.');
@@ -111,6 +145,9 @@ class DaikinCloudPlatform {
             if (!this.controller) {
                 return;
             }
+            // Register listeners before authenticating: an 'error' emitted without a
+            // listener would throw.
+            this.registerControllerListeners(this.controller);
             // Handle authentication based on mode
             if (!this.controller.isAuthenticated()) {
                 if (this.authMode === 'mobile_app') {
@@ -121,7 +158,7 @@ class DaikinCloudPlatform {
                         this.log.info('[Auth] Authentication successful!');
                     }
                     catch (error) {
-                        this.log.error(`[Auth] Authentication failed: ${error.message}`);
+                        this.log.error(`[Auth] Authentication failed: ${(0, errors_1.toMessage)(error)}`);
                         this.log.info('--------------- End Daikin info for debugging reasons --------------------');
                         return;
                     }
@@ -132,45 +169,14 @@ class DaikinCloudPlatform {
                     return;
                 }
             }
-            this.controller.on('rate_limit_status', (rateLimitStatus) => {
-                if (rateLimitStatus.remainingDay && rateLimitStatus.remainingDay <= constants_1.RATE_LIMIT_WARNING_THRESHOLD) {
-                    this.log.warn(`[Rate Limit] Rate limit almost reached, you only have ${rateLimitStatus.remainingDay} calls left today`);
-                }
-                // Only show minute limits if available (Developer Portal mode)
-                const minuteInfo = rateLimitStatus.limitMinute !== undefined
-                    ? ` -- this minute: ${rateLimitStatus.remainingMinute}/${rateLimitStatus.limitMinute}`
-                    : '';
-                this.log.debug(`[Rate Limit] Remaining calls today: ${rateLimitStatus.remainingDay}/${rateLimitStatus.limitDay}${minuteInfo}`);
-            });
-            this.controller.on('error', (error) => {
-                this.log.error(`[Error] ${error}`);
-            });
-            this.controller.on('log', (message) => {
-                this.log.info(message);
-            });
-            // WebSocket event handlers
-            this.controller.on('websocket_connected', () => {
-                this.log.info('[WebSocket] Connected - receiving real-time updates');
-            });
-            this.controller.on('websocket_disconnected', (info) => {
-                if (info?.reconnecting) {
-                    this.log.debug('[WebSocket] Disconnected, attempting to reconnect...');
-                }
-                else {
-                    this.log.info('[WebSocket] Disconnected');
-                }
-            });
-            this.controller.on('websocket_device_update', (update) => {
-                this.log.debug(`[WebSocket] Device update: ${update.deviceId} - ${update.characteristicName}`, JSON.stringify(update.data));
-                this.handleWebSocketDeviceUpdate(update);
-            });
             const onInvalidGrantError = () => this.onInvalidGrantError(tokenFilePath);
             const devices = await this.discoverDevices(this.controller, onInvalidGrantError);
-            if (devices.length > 0) {
+            if (devices.length > 0 && !this.isShuttingDown) {
                 this.createDevices(devices);
+                this.pollingStarted = true;
                 this.startUpdateDevicesInterval();
                 // Enable WebSocket for real-time updates (unless explicitly disabled)
-                if (this.config.enableWebSocket !== false) {
+                if (this.configManager.isWebSocketEnabled()) {
                     await this.enableWebSocket();
                 }
             }
@@ -179,8 +185,13 @@ class DaikinCloudPlatform {
         // Shutdown handler: clean up timers, WebSocket, and device listeners on platform shutdown
         this.api.on('shutdown', () => {
             this.log.debug('[Platform] Shutting down, cleaning up resources...');
-            clearInterval(this.updateInterval);
+            this.isShuttingDown = true;
+            this.stopPolling();
             clearTimeout(this.forceUpdateTimeout);
+            this.forceUpdateTimeout = undefined;
+            clearTimeout(this.rateLimitWriteTimer);
+            this.rateLimitWriteTimer = undefined;
+            this.flushRateLimitStatus();
             this.controller?.disableWebSocket();
             for (const [uuid, listener] of this.deviceListeners) {
                 const accessory = this.accessories.find(a => a.UUID === uuid);
@@ -191,6 +202,33 @@ class DaikinCloudPlatform {
             this.deviceListeners.clear();
         });
     }
+    registerControllerListeners(controller) {
+        controller.on('rate_limit_status', (rateLimitStatus) => this.onRateLimitStatus(rateLimitStatus));
+        controller.on('error', (error) => {
+            this.log.error(`[Error] ${(0, errors_1.toMessage)(error)}`);
+        });
+        controller.on('log', (message) => {
+            this.log.info(message);
+        });
+        controller.on('websocket_connected', () => this.onWebSocketConnected());
+        controller.on('websocket_disconnected', (info) => {
+            if (info?.reconnecting) {
+                this.log.debug('[WebSocket] Disconnected, attempting to reconnect...');
+            }
+            else {
+                this.log.info('[WebSocket] Disconnected');
+            }
+            // Push updates are gone: fall back to the configured polling interval
+            if (this.pollingStarted) {
+                this.startUpdateDevicesInterval();
+            }
+        });
+        // The controller already applied the update to the device, which emits
+        // 'updated' and makes the accessory refresh its characteristics.
+        controller.on('websocket_device_update', (update) => {
+            this.log.debug(`[WebSocket] Device update: ${update.deviceId} - ${update.characteristicName}`, lazyJson(() => update.data));
+        });
+    }
     configureAccessory(accessory) {
         this.log.info('[Platform] Loading accessory from cache:', accessory.displayName);
         this.accessories.push(accessory);
@@ -217,8 +255,8 @@ class DaikinCloudPlatform {
                 const uuid = this.api.hap.uuid.generate(deviceId);
                 const deviceModel = device.getDescription().deviceModel;
                 const existingAccessory = this.accessories.find(accessory => accessory.UUID === uuid);
-                this.log.debug('Create Device', deviceModel, JSON.stringify(api_1.DaikinCloudRepo.maskSensitiveCloudDeviceData(device.desc), null, 4));
-                if (this.isExcludedDevice(this.config.excludedDevicesByDeviceId, deviceId)) {
+                this.log.debug('Create Device', deviceModel, lazyJson(() => api_1.DaikinCloudRepo.maskSensitiveCloudDeviceData(device.desc), 4));
+                if (this.configManager.isDeviceExcluded(deviceId)) {
                     this.log.info(`[Platform] Device ${deviceModel} (id: ${deviceId}) is excluded, don't add accessory`);
                     if (existingAccessory) {
                         this.api.unregisterPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [existingAccessory]);
@@ -250,7 +288,7 @@ class DaikinCloudPlatform {
                 if (error instanceof Error) {
                     this.log.error(`[Platform] Failed to create accessory: ${error.message}`);
                     this.log.debug('[Platform] Error details:', error.stack);
-                    this.log.debug('[Platform] Device JSON:', JSON.stringify(api_1.DaikinCloudRepo.maskSensitiveCloudDeviceData(device.desc), null, 2));
+                    this.log.debug('[Platform] Device JSON:', lazyJson(() => api_1.DaikinCloudRepo.maskSensitiveCloudDeviceData(device.desc), 2));
                 }
             }
         }
@@ -265,18 +303,51 @@ class DaikinCloudPlatform {
     registerDeviceListener(accessory, listener) {
         this.deviceListeners.set(accessory.UUID, listener);
     }
-    async updateDevices() {
-        if (!this.controller) {
-            return;
+    /**
+     * Fetch fresh device data. Overlapping callers (periodic poll, forced update,
+     * WebSocket reconnect catch-up) share a single in-flight request.
+     */
+    updateDevices() {
+        const controller = this.controller;
+        if (!controller) {
+            return Promise.resolve();
         }
-        try {
-            await this.controller.updateAllDeviceData();
+        if (!this.inFlightUpdate) {
+            this.inFlightUpdate = (async () => {
+                try {
+                    await controller.updateAllDeviceData();
+                    this.consecutivePollFailures = 0;
+                }
+                catch (error) {
+                    this.consecutivePollFailures++;
+                    this.log.error(`[API Syncing] Failed to update devices data: ${(0, errors_1.toMessage)(error)}`);
+                }
+            })().finally(() => {
+                this.inFlightUpdate = undefined;
+            });
         }
-        catch (error) {
-            this.log.error(`[API Syncing] Failed to update devices data: ${JSON.stringify(error)}`);
+        return this.inFlightUpdate;
+    }
+    /**
+     * Poll now, then schedule the next periodic poll.
+     */
+    async pollNow() {
+        if (this.isShuttingDown) {
+            return;
         }
+        this.stopPolling();
+        await this.updateDevices();
+        this.startUpdateDevicesInterval();
     }
-    forceUpdateDevices(delay = Math.max(0, this.config.forceUpdateDelay || constants_1.DEFAULT_FORCE_UPDATE_DELAY_MS)) {
+    forceUpdateDevices(delay = this.configManager.getForceUpdateDelayMs()) {
+        if (this.isShuttingDown) {
+            return;
+        }
+        // With a healthy WebSocket the change is pushed to us; a follow-up GET would only cost quota.
+        if (this.isWebSocketConnected()) {
+            this.log.debug('[API Syncing] WebSocket connected, skipping forced update (waiting for push update)');
+            return;
+        }
         // Trailing debounce: reset the timer on every change so a burst of rapid
         // SETs (e.g. toggling power, fan speed and mode in quick succession)
         // collapses into a single poll fired `delay` ms after the *last* change,
@@ -289,29 +360,110 @@ class DaikinCloudPlatform {
             this.log.debug(`[API Syncing] Force update devices data (delayed by ${delay}ms)`);
             // Pause periodic polling while we wait for the change to settle; it is
             // restarted once the debounced update fires.
-            clearInterval(this.updateInterval);
+            this.stopPolling();
         }
-        this.forceUpdateTimeout = setTimeout(async () => {
+        this.forceUpdateTimeout = setTimeout(() => {
             this.forceUpdateTimeout = undefined;
-            try {
-                await this.updateDevices();
-            }
-            catch (error) {
-                this.log.error(`[API Syncing] Force update failed: ${error.message}`);
-            }
-            this.startUpdateDevicesInterval();
+            void this.pollNow();
         }, delay);
     }
+    /**
+     * (Re)schedule the next periodic poll. Always replaces any previously
+     * scheduled poll, so there is never more than one pending.
+     */
     startUpdateDevicesInterval() {
-        this.log.debug(`[API Syncing] (Re)starting update devices interval every ${this.updateIntervalDelay / constants_1.ONE_MINUTE_MS} minutes`);
-        this.updateInterval = setInterval(async () => {
-            try {
-                await this.updateDevices();
-            }
-            catch (error) {
-                this.log.error(`[API Syncing] Periodic update failed: ${error.message}`);
+        this.stopPolling();
+        // Shutting down, or a pending forced update will restart polling when it fires
+        if (this.isShuttingDown || this.forceUpdateTimeout) {
+            return;
+        }
+        const delay = this.getPollInterval();
+        this.log.debug(`[API Syncing] Next update of devices data in ${Math.round(delay / constants_1.ONE_MINUTE_MS)} minutes`);
+        this.pollTimer = setTimeout(() => {
+            this.pollTimer = undefined;
+            void this.pollNow();
+        }, delay);
+    }
+    stopPolling() {
+        clearTimeout(this.pollTimer);
+        this.pollTimer = undefined;
+    }
+    getPollInterval() {
+        return computePollInterval({
+            configuredMs: this.updateIntervalDelay,
+            webSocketConnected: this.isWebSocketConnected(),
+            consecutiveFailures: this.consecutivePollFailures,
+            remainingDay: this.remainingDay,
+        });
+    }
+    isWebSocketConnected() {
+        return this.controller?.isWebSocketConnected() === true;
+    }
+    onWebSocketConnected() {
+        this.log.info('[WebSocket] Connected - receiving real-time updates');
+        const isReconnect = this.webSocketHasConnected;
+        this.webSocketHasConnected = true;
+        if (!this.pollingStarted || this.isShuttingDown) {
+            return;
+        }
+        if (isReconnect) {
+            // Catch up on anything that changed while the socket was down
+            void this.pollNow();
+        }
+        else {
+            // Push updates are flowing: stretch polling to the safety interval
+            this.startUpdateDevicesInterval();
+        }
+    }
+    onRateLimitStatus(rateLimitStatus) {
+        const { remainingDay, limitDay } = rateLimitStatus;
+        if (remainingDay !== undefined) {
+            this.remainingDay = remainingDay;
+            if (remainingDay <= constants_1.RATE_LIMIT_WARNING_THRESHOLD) {
+                this.log.warn(`[Rate Limit] Rate limit almost reached, you only have ${remainingDay} calls left today`);
             }
-        }, this.updateIntervalDelay);
+        }
+        // Only show minute limits if available (Developer Portal mode)
+        const minuteInfo = rateLimitStatus.limitMinute !== undefined
+            ? ` -- this minute: ${rateLimitStatus.remainingMinute}/${rateLimitStatus.limitMinute}`
+            : '';
+        this.log.debug(`[Rate Limit] Remaining calls today: ${remainingDay}/${limitDay}${minuteInfo}`);
+        this.saveRateLimitStatus(rateLimitStatus);
+    }
+    /**
+     * Persist the latest rate-limit headers for the settings UI (throttled,
+     * best effort: failures are logged at debug level and never thrown).
+     */
+    saveRateLimitStatus(rateLimitStatus) {
+        this.pendingRateLimitStatus = {
+            ...rateLimitStatus,
+            mode: this.authMode,
+            updatedAt: new Date().toISOString(),
+        };
+        if (this.rateLimitWriteTimer || this.isShuttingDown) {
+            return;
+        }
+        const wait = Math.max(0, this.lastRateLimitWriteAt + RATE_LIMIT_FILE_MIN_WRITE_INTERVAL_MS - Date.now());
+        this.rateLimitWriteTimer = setTimeout(() => {
+            this.rateLimitWriteTimer = undefined;
+            this.flushRateLimitStatus();
+        }, wait);
+    }
+    flushRateLimitStatus() {
+        const status = this.pendingRateLimitStatus;
+        if (!status) {
+            return;
+        }
+        this.pendingRateLimitStatus = undefined;
+        this.lastRateLimitWriteAt = Date.now();
+        const filePath = (0, node_path_1.resolve)(this.storagePath, constants_1.RATE_LIMIT_STATUS_FILE);
+        const tmpPath = `${filePath}.tmp`;
+        // Write-then-rename so the UI never reads a half-written file
+        node_fs_1.default.promises.writeFile(tmpPath, JSON.stringify(status, null, 2))
+            .then(() => node_fs_1.default.promises.rename(tmpPath, filePath))
+            .catch((error) => {
+            this.log.debug(`[Rate Limit] Could not write ${constants_1.RATE_LIMIT_STATUS_FILE}: ${(0, errors_1.toMessage)(error)}`);
+        });
     }
     async enableWebSocket() {
         if (!this.controller) {
@@ -322,26 +474,10 @@ class DaikinCloudPlatform {
             await this.controller.enableWebSocket();
         }
         catch (error) {
-            this.log.warn(`[WebSocket] Failed to enable: ${error.message}`);
+            this.log.warn(`[WebSocket] Failed to enable: ${(0, errors_1.toMessage)(error)}`);
             this.log.warn('[WebSocket] Falling back to polling-only mode');
         }
     }
-    isExcludedDevice(excludedDevicesByDeviceId, deviceId) {
-        return Array.isArray(excludedDevicesByDeviceId) && excludedDevicesByDeviceId.includes(deviceId);
-    }
-    getPrivacyFriendlyConfig(config) {
-        return {
-            ...config,
-            clientId: strings_1.StringUtils.mask(config.clientId),
-            clientSecret: strings_1.StringUtils.mask(config.clientSecret),
-            daikinEmail: strings_1.StringUtils.mask(config.daikinEmail),
-            daikinPassword: config.daikinPassword ? '***' : undefined,
-            // Legacy aliases, masked too so they never leak into debug logs
-            email: strings_1.StringUtils.mask(config.email),
-            password: config.password ? '***' : undefined,
-            excludedDevicesByDeviceId: config.excludedDevicesByDeviceId ? config.excludedDevicesByDeviceId.map((deviceId) => strings_1.StringUtils.mask(deviceId)) : [],
-        };
-    }
     onInvalidGrantError(tokenFilePath) {
         this.log.warn('[API Syncing] TokenSet is invalid, removing TokenSet file');
         try {
@@ -352,22 +488,6 @@ class DaikinCloudPlatform {
             this.log.error('[API Syncing] TokenSet file could not be removed. Location:', tokenFilePath, e);
         }
     }
-    /**
-       * Handle WebSocket device updates by pushing updated values to HomeKit
-       */
-    handleWebSocketDeviceUpdate(update) {
-        // Find the accessory for this device
-        const accessory = this.accessories.find(a => a.context.device.getId() === update.deviceId);
-        if (!accessory) {
-            this.log.debug(`[WebSocket] No accessory found for device ${update.deviceId}`);
-            return;
-        }
-        // Use the UpdateMapper to apply the update
-        const result = this.updateMapper.applyUpdate(accessory, update);
-        if (result.success) {
-            this.log.debug(`[WebSocket] Updated ${result.updated.join(', ')}`);
-        }
-    }
 }
 exports.DaikinCloudPlatform = DaikinCloudPlatform;
 //# sourceMappingURL=platform.js.map