homebridge-mitsubishi-comfort 1.3.0 → 1.3.3

package/dist/accessory.d.ts

@@ -15,6 +15,7 @@ export declare class KumoThermostatAccessory {
     private hasHumiditySensor;
     private lastUpdateTimestamp;
     private lastUpdateSource;
+    private hasReceivedValidUpdate;
     constructor(platform: KumoV3Platform, accessory: PlatformAccessory, kumoAPI: KumoAPI, pollIntervalSeconds?: number);
     private handleStreamingUpdate;
     getSiteId(): string;

package/dist/accessory.js

@@ -12,6 +12,7 @@ class KumoThermostatAccessory {
         this.hasHumiditySensor = false;
         this.lastUpdateTimestamp = 0;
         this.lastUpdateSource = 'none';
+        this.hasReceivedValidUpdate = false;
         this.deviceSerial = this.accessory.context.device.deviceSerial;
         this.siteId = this.accessory.context.device.siteId;
         this.pollIntervalMs = (pollIntervalSeconds || settings_1.POLL_INTERVAL / 1000) * 1000;
@@ -125,6 +126,7 @@ class KumoThermostatAccessory {
                 spAuto: zone.adapter.spAuto,
             };
             this.currentStatus = status;
+            this.hasReceivedValidUpdate = true;
             this.platform.log.debug(`${this.accessory.displayName}: ${status.roomTemp}°C (target: ${this.getTargetTempFromStatus(status)}°C, mode: ${status.operationMode})`);
             this.service.updateCharacteristic(this.platform.Characteristic.CurrentHeatingCoolingState, this.mapToCurrentHeatingCoolingState(status));
             this.service.updateCharacteristic(this.platform.Characteristic.TargetHeatingCoolingState, this.mapToTargetHeatingCoolingState(status));
@@ -200,13 +202,8 @@ class KumoThermostatAccessory {
     }
     async getCurrentHeatingCoolingState() {
         if (!this.currentStatus) {
-            const status = await this.kumoAPI.getDeviceStatus(this.deviceSerial);
-            if (status) {
-                this.currentStatus = status;
-            }
-            else {
-                return this.platform.Characteristic.CurrentHeatingCoolingState.OFF;
-            }
+            this.platform.log.debug('No status available yet for getCurrentHeatingCoolingState, returning OFF');
+            return this.platform.Characteristic.CurrentHeatingCoolingState.OFF;
         }
         const state = this.mapToCurrentHeatingCoolingState(this.currentStatus);
         this.platform.log.debug('Get CurrentHeatingCoolingState:', state);
@@ -214,13 +211,8 @@ class KumoThermostatAccessory {
     }
     async getTargetHeatingCoolingState() {
         if (!this.currentStatus) {
-            const status = await this.kumoAPI.getDeviceStatus(this.deviceSerial);
-            if (status) {
-                this.currentStatus = status;
-            }
-            else {
-                return this.platform.Characteristic.TargetHeatingCoolingState.OFF;
-            }
+            this.platform.log.debug('No status available yet for getTargetHeatingCoolingState, returning OFF');
+            return this.platform.Characteristic.TargetHeatingCoolingState.OFF;
         }
         const state = this.mapToTargetHeatingCoolingState(this.currentStatus);
         this.platform.log.debug('Get TargetHeatingCoolingState:', state);
@@ -229,50 +221,51 @@ class KumoThermostatAccessory {
     async setTargetHeatingCoolingState(value) {
         this.platform.log.debug('Set TargetHeatingCoolingState:', value);
         let operationMode;
+        let modeName;
         switch (value) {
             case this.platform.Characteristic.TargetHeatingCoolingState.OFF:
                 operationMode = 'off';
+                modeName = 'OFF';
                 break;
             case this.platform.Characteristic.TargetHeatingCoolingState.HEAT:
                 operationMode = 'heat';
+                modeName = 'HEAT';
                 break;
             case this.platform.Characteristic.TargetHeatingCoolingState.COOL:
                 operationMode = 'cool';
+                modeName = 'COOL';
                 break;
             case this.platform.Characteristic.TargetHeatingCoolingState.AUTO:
                 operationMode = 'auto';
+                modeName = 'AUTO';
                 break;
             default:
                 this.platform.log.error('Unknown target heating cooling state:', value);
                 return;
         }
+        this.platform.log.info(`[MODE CHANGE] ${this.accessory.displayName}: HomeKit sent ${modeName} mode`);
         const success = await this.kumoAPI.sendCommand(this.deviceSerial, {
             operationMode,
         });
         if (success) {
+            this.platform.log.info(`[MODE CHANGE] ${this.accessory.displayName}: Command accepted by API`);
             if (this.currentStatus) {
                 this.currentStatus.operationMode = operationMode;
                 this.currentStatus.power = operationMode === 'off' ? 0 : 1;
             }
         }
         else {
-            this.platform.log.error(`Failed to set target heating cooling state for ${this.accessory.displayName}`);
+            this.platform.log.error(`[MODE CHANGE] ${this.accessory.displayName}: Failed to set mode to ${modeName}`);
         }
     }
     async getCurrentTemperature() {
         if (!this.currentStatus) {
-            const status = await this.kumoAPI.getDeviceStatus(this.deviceSerial);
-            if (status) {
-                this.currentStatus = status;
-            }
-            else {
-                this.platform.log.debug('No status available yet for getCurrentTemperature, returning default');
-                return 20;
-            }
+            this.platform.log.debug('No status available yet for getCurrentTemperature, returning default');
+            return 20;
         }
         const temp = this.currentStatus.roomTemp;
         if (temp === undefined || temp === null || isNaN(temp)) {
-            if (this.lastUpdateSource !== 'none') {
+            if (this.hasReceivedValidUpdate) {
                 this.platform.log.warn(`Invalid roomTemp value for ${this.accessory.displayName}:`, temp);
             }
             return 20;
@@ -282,18 +275,12 @@ class KumoThermostatAccessory {
     }
     async getTargetTemperature() {
         if (!this.currentStatus) {
-            const status = await this.kumoAPI.getDeviceStatus(this.deviceSerial);
-            if (status) {
-                this.currentStatus = status;
-            }
-            else {
-                this.platform.log.debug('No status available yet for getTargetTemperature, returning default');
-                return 20;
-            }
+            this.platform.log.debug('No status available yet for getTargetTemperature, returning default');
+            return 20;
         }
         const temp = this.getTargetTempFromStatus(this.currentStatus);
         if (temp === undefined || temp === null || isNaN(temp)) {
-            if (this.lastUpdateSource !== 'none') {
+            if (this.hasReceivedValidUpdate) {
                 this.platform.log.warn(`Invalid target temperature value for ${this.accessory.displayName}:`, temp);
             }
             return 20;

package/dist/kumo-api.d.ts

@@ -14,14 +14,17 @@ export declare class KumoAPI {
     private socket;
     private streamingEnabled;
     private deviceUpdateCallbacks;
-    private reconnectAttempts;
-    private maxReconnectAttempts;
-    private lastStreamingUpdate;
     private streamingHealthCallbacks;
     private healthCheckTimer;
     private streamingHealthCheckInterval;
-    private streamingStaleThreshold;
     private isStreamingHealthy;
+    private refreshRetryCount;
+    private lastRefreshAttempt;
+    private loginRetryCount;
+    private lastLoginAttempt;
+    private readonly maxRetryAttempts;
+    private readonly baseRetryDelay;
+    private readonly minLoginInterval;
     constructor(username: string, password: string, log: Logger, debug?: boolean, enableStreaming?: boolean);
     private maskToken;
     login(): Promise<boolean>;
@@ -38,13 +41,13 @@ export declare class KumoAPI {
     subscribeToDevice(deviceSerial: string, callback: DeviceUpdateCallback): void;
     unsubscribeFromDevice(deviceSerial: string): void;
     isStreamingConnected(): boolean;
-    setStreamingHealthConfig(checkInterval: number, staleThreshold: number): void;
+    setStreamingHealthCheckInterval(checkIntervalSec: number): void;
     onStreamingHealthChange(callback: (isHealthy: boolean) => void): void;
     getStreamingHealth(): boolean;
-    private updateStreamingTimestamp;
     private checkStreamingHealth;
     private notifyHealthChange;
     private startHealthChecks;
     private stopHealthChecks;
     destroy(): void;
+    reconnectStreaming(): Promise<void>;
 }

package/dist/kumo-api.js

@@ -21,14 +21,17 @@ class KumoAPI {
         this.socket = null;
         this.streamingEnabled = true;
         this.deviceUpdateCallbacks = new Map();
-        this.reconnectAttempts = 0;
-        this.maxReconnectAttempts = 5;
-        this.lastStreamingUpdate = new Map();
         this.streamingHealthCallbacks = new Set();
         this.healthCheckTimer = null;
         this.streamingHealthCheckInterval = 30000;
-        this.streamingStaleThreshold = 60000;
         this.isStreamingHealthy = false;
+        this.refreshRetryCount = 0;
+        this.lastRefreshAttempt = 0;
+        this.loginRetryCount = 0;
+        this.lastLoginAttempt = 0;
+        this.maxRetryAttempts = 5;
+        this.baseRetryDelay = 5000;
+        this.minLoginInterval = 10000;
         this.debugMode = debug;
         this.streamingEnabled = enableStreaming;
         if (this.debugMode) {
@@ -49,6 +52,14 @@ class KumoAPI {
         return `${token.substring(0, 4)}...${token.substring(token.length - 4)}`;
     }
     async login() {
+        var _a;
+        const timeSinceLastLogin = Date.now() - this.lastLoginAttempt;
+        if (this.lastLoginAttempt > 0 && timeSinceLastLogin < this.minLoginInterval) {
+            const waitTime = this.minLoginInterval - timeSinceLastLogin;
+            this.log.warn(`Rate limit protection: waiting ${Math.round(waitTime / 1000)}s before login attempt`);
+            await new Promise(resolve => setTimeout(resolve, waitTime));
+        }
+        this.lastLoginAttempt = Date.now();
         try {
             this.log.debug('Attempting to login to Kumo Cloud API');
             const response = await (0, node_fetch_1.default)(`${settings_1.API_BASE_URL}/login`, {
@@ -66,17 +77,42 @@ class KumoAPI {
             });
             if (!response.ok) {
                 const errorText = await response.text();
+                if (response.status === 429) {
+                    this.loginRetryCount++;
+                    this.log.error(`Login rate limited (429). Retry count: ${this.loginRetryCount}`);
+                    if (this.loginRetryCount >= this.maxRetryAttempts) {
+                        this.log.error(`Login retry limit reached (${this.maxRetryAttempts} attempts). Giving up.`);
+                        this.loginRetryCount = 0;
+                        return false;
+                    }
+                    const backoffDelay = Math.min(this.baseRetryDelay * Math.pow(2, this.loginRetryCount), 120000);
+                    this.log.warn(`Retrying login in ${Math.round(backoffDelay / 1000)}s...`);
+                    await new Promise(resolve => setTimeout(resolve, backoffDelay));
+                    return await this.login();
+                }
                 this.log.error(`Login failed with status: ${response.status}`);
                 if (this.debugMode && errorText) {
                     this.log.debug(`Login error response: ${errorText}`);
                 }
+                this.loginRetryCount = 0;
                 return false;
             }
             const data = await response.json();
             this.accessToken = data.token.access;
             this.refreshToken = data.token.refresh;
+            const wasRecovery = this.loginRetryCount > 0 || this.refreshRetryCount > 0 || ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.connected);
+            if (this.loginRetryCount > 0) {
+                this.log.info(`Login recovered after ${this.loginRetryCount} retry attempt(s)`);
+            }
+            else {
+                this.log.info('Successfully logged in to Kumo Cloud API');
+            }
+            this.loginRetryCount = 0;
+            this.refreshRetryCount = 0;
             this.tokenExpiresAt = Date.now() + settings_1.TOKEN_REFRESH_INTERVAL;
-            this.log.info('Successfully logged in to Kumo Cloud API');
+            if (wasRecovery) {
+                await this.reconnectStreaming();
+            }
             this.scheduleTokenRefresh();
             return true;
         }
@@ -90,6 +126,7 @@ class KumoAPI {
             else {
                 this.log.error('Login error: Unknown error occurred');
             }
+            this.loginRetryCount = 0;
             return false;
         }
     }
@@ -108,6 +145,16 @@ class KumoAPI {
             this.log.error('No refresh token available, need to login again');
             return await this.login();
         }
+        const timeSinceLastAttempt = Date.now() - this.lastRefreshAttempt;
+        if (this.refreshRetryCount > 0) {
+            const backoffDelay = Math.min(this.baseRetryDelay * Math.pow(2, this.refreshRetryCount - 1), 60000);
+            if (timeSinceLastAttempt < backoffDelay) {
+                const waitTime = backoffDelay - timeSinceLastAttempt;
+                this.log.warn(`Rate limit backoff: waiting ${Math.round(waitTime / 1000)}s before retry attempt ${this.refreshRetryCount + 1}/${this.maxRetryAttempts}`);
+                await new Promise(resolve => setTimeout(resolve, waitTime));
+            }
+        }
+        this.lastRefreshAttempt = Date.now();
         try {
             this.log.debug('Refreshing access token');
             const response = await (0, node_fetch_1.default)(`${settings_1.API_BASE_URL}/refresh`, {
@@ -124,14 +171,32 @@ class KumoAPI {
             if (!response.ok) {
                 const errorText = await response.text();
                 this.log.warn(`Token refresh failed (${response.status}): ${errorText}`);
+                if (response.status === 429) {
+                    this.refreshRetryCount++;
+                    if (this.refreshRetryCount >= this.maxRetryAttempts) {
+                        this.log.error(`Rate limit retry limit reached (${this.maxRetryAttempts} attempts). Falling back to full login.`);
+                        this.refreshRetryCount = 0;
+                        return await this.login();
+                    }
+                    this.log.warn(`Rate limited. Will retry with exponential backoff (attempt ${this.refreshRetryCount}/${this.maxRetryAttempts})`);
+                    return await this.refreshAccessToken();
+                }
                 this.log.warn('Attempting full login');
+                this.refreshRetryCount = 0;
                 return await this.login();
             }
             const data = await response.json();
             this.accessToken = data.access;
             this.refreshToken = data.refresh;
             this.tokenExpiresAt = Date.now() + settings_1.TOKEN_REFRESH_INTERVAL;
-            this.log.debug('Access token refreshed successfully');
+            if (this.refreshRetryCount > 0) {
+                this.log.info(`Token refresh recovered after ${this.refreshRetryCount} retry attempt(s)`);
+            }
+            else {
+                this.log.debug('Access token refreshed successfully');
+            }
+            this.refreshRetryCount = 0;
+            await this.reconnectStreaming();
             this.scheduleTokenRefresh();
             return true;
         }
@@ -142,6 +207,7 @@ class KumoAPI {
             else {
                 this.log.error('Token refresh error: Unknown error occurred');
             }
+            this.refreshRetryCount = 0;
             return await this.login();
         }
     }
@@ -214,9 +280,9 @@ class KumoAPI {
             }
             if (!response.ok) {
                 this.log.error(`Request failed with status: ${response.status}`);
-                if (this.debugMode) {
-                    const errorText = await response.text();
-                    this.log.info(`  Error response: ${errorText}`);
+                const errorText = await response.text();
+                if (this.debugMode || response.status === 400) {
+                    this.log.error(`  Error response: ${errorText}`);
                 }
                 return null;
             }
@@ -352,6 +418,7 @@ class KumoAPI {
             this.log.info('Starting streaming connection...');
             this.socket = (0, socket_io_client_1.io)(settings_1.SOCKET_BASE_URL, {
                 transports: ['polling', 'websocket'],
+                timeout: 20000,
                 extraHeaders: {
                     'Authorization': `Bearer ${this.accessToken}`,
                     'Accept': '*/*',
@@ -361,14 +428,14 @@ class KumoAPI {
             this.socket.on('connect', () => {
                 var _a, _b;
                 this.log.info(`✓ Streaming connected (ID: ${(_a = this.socket) === null || _a === void 0 ? void 0 : _a.id})`);
-                this.reconnectAttempts = 0;
                 for (const deviceSerial of deviceSerials) {
+                    if (!deviceSerial || typeof deviceSerial !== 'string' || deviceSerial.trim().length === 0) {
+                        this.log.warn(`Skipping invalid device serial: ${deviceSerial}`);
+                        continue;
+                    }
                     this.log.debug(`Subscribing to device: ${deviceSerial}`);
                     (_b = this.socket) === null || _b === void 0 ? void 0 : _b.emit('subscribe', deviceSerial);
                 }
-                for (const deviceSerial of deviceSerials) {
-                    this.lastStreamingUpdate.set(deviceSerial, Date.now());
-                }
                 this.isStreamingHealthy = true;
                 this.notifyHealthChange(false, true);
                 this.startHealthChecks();
@@ -380,7 +447,6 @@ class KumoAPI {
                 if (!deviceSerial) {
                     return;
                 }
-                this.updateStreamingTimestamp(deviceSerial);
                 if (this.debugMode) {
                     this.log.debug(`Stream update for ${deviceSerial}: temp=${data.roomTemp}°C, mode=${data.operationMode}, power=${data.power}`);
                     this.log.info(`  RAW Streaming Update JSON for ${deviceSerial}:`);
@@ -397,13 +463,6 @@ class KumoAPI {
                 this.isStreamingHealthy = false;
                 this.notifyHealthChange(wasHealthy, false);
                 this.stopHealthChecks();
-                if (reason !== 'io client disconnect' && this.reconnectAttempts < this.maxReconnectAttempts) {
-                    this.reconnectAttempts++;
-                    this.log.info(`Attempting to reconnect (${this.reconnectAttempts}/${this.maxReconnectAttempts})...`);
-                }
-                else if (this.reconnectAttempts >= this.maxReconnectAttempts) {
-                    this.log.error('Max reconnect attempts reached - polling will handle updates');
-                }
             });
             this.socket.on('connect_error', (error) => {
                 this.log.error(`Streaming connection error: ${error.message}`);
@@ -432,10 +491,9 @@ class KumoAPI {
         var _a;
         return ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.connected) || false;
     }
-    setStreamingHealthConfig(checkInterval, staleThreshold) {
-        this.streamingHealthCheckInterval = checkInterval * 1000;
-        this.streamingStaleThreshold = staleThreshold * 1000;
-        this.log.debug(`Streaming health config: check every ${checkInterval}s, stale after ${staleThreshold}s`);
+    setStreamingHealthCheckInterval(checkIntervalSec) {
+        this.streamingHealthCheckInterval = checkIntervalSec * 1000;
+        this.log.debug(`Streaming health check interval: ${checkIntervalSec}s`);
     }
     onStreamingHealthChange(callback) {
         this.streamingHealthCallbacks.add(callback);
@@ -443,9 +501,6 @@ class KumoAPI {
     getStreamingHealth() {
         return this.isStreamingHealthy;
     }
-    updateStreamingTimestamp(deviceSerial) {
-        this.lastStreamingUpdate.set(deviceSerial, Date.now());
-    }
     checkStreamingHealth() {
         const wasHealthy = this.isStreamingHealthy;
         this.isStreamingHealthy = this.isStreamingConnected();
@@ -481,7 +536,6 @@ class KumoAPI {
         }
         this.stopHealthChecks();
         this.streamingHealthCallbacks.clear();
-        this.lastStreamingUpdate.clear();
         this.log.debug('Streaming health monitoring stopped');
         if (this.socket) {
             this.log.debug('Disconnecting streaming connection');
@@ -489,5 +543,22 @@ class KumoAPI {
             this.socket = null;
         }
     }
+    async reconnectStreaming() {
+        if (!this.streamingEnabled) {
+            return;
+        }
+        const deviceSerials = Array.from(this.deviceUpdateCallbacks.keys());
+        if (deviceSerials.length === 0) {
+            this.log.debug('No devices subscribed, skipping streaming reconnect');
+            return;
+        }
+        this.log.debug('Reconnecting streaming with refreshed token...');
+        if (this.socket) {
+            this.socket.removeAllListeners('disconnect');
+            this.socket.disconnect();
+            this.socket = null;
+        }
+        await this.startStreaming(deviceSerials);
+    }
 }
 exports.KumoAPI = KumoAPI;

package/dist/platform.d.ts

@@ -14,6 +14,9 @@ export declare class KumoV3Platform implements DynamicPlatformPlugin {
     private readonly degradedPollInterval;
     private isStreamingHealthy;
     private isDegradedMode;
+    private readonly modeChangeHysteresisMs;
+    private pendingModeChange;
+    private pendingModeHealthy;
     constructor(log: Logger, config: PlatformConfig, api: API);
     private cleanup;
     configureAccessory(accessory: PlatformAccessory): void;

package/dist/platform.js

@@ -17,6 +17,9 @@ class KumoV3Platform {
         this.siteAccessories = new Map();
         this.isStreamingHealthy = false;
         this.isDegradedMode = false;
+        this.modeChangeHysteresisMs = 10000;
+        this.pendingModeChange = null;
+        this.pendingModeHealthy = null;
         this.kumoConfig = config;
         this.log.debug('Initializing platform:', this.config.name);
         const kumoConfig = this.kumoConfig;
@@ -42,8 +45,7 @@ class KumoV3Platform {
         this.log.debug(`Degraded polling interval: ${this.degradedPollInterval / 1000}s`);
         this.kumoAPI = new kumo_api_1.KumoAPI(kumoConfig.username, kumoConfig.password, this.log, kumoConfig.debug || false);
         const healthCheckInterval = kumoConfig.streamingHealthCheckInterval || 30;
-        const staleThreshold = kumoConfig.streamingStaleThreshold || 60;
-        this.kumoAPI.setStreamingHealthConfig(healthCheckInterval, staleThreshold);
+        this.kumoAPI.setStreamingHealthCheckInterval(healthCheckInterval);
         this.kumoAPI.onStreamingHealthChange((isHealthy) => {
             this.handleStreamingHealthChange(isHealthy);
         });
@@ -156,7 +158,6 @@ class KumoV3Platform {
                     this.log.warn('Streaming failed to start - falling back to polling');
                 }
                 const healthCheckInterval = this.kumoConfig.streamingHealthCheckInterval || 30;
-                const staleThreshold = this.kumoConfig.streamingStaleThreshold || 60;
                 this.log.info('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
                 this.log.info('Mitsubishi Comfort Plugin Configuration');
                 this.log.info('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
@@ -165,7 +166,6 @@ class KumoV3Platform {
                 this.log.info(`Normal poll interval: ${(this.kumoConfig.pollInterval || 30)}s`);
                 this.log.info(`Degraded poll interval: ${this.degradedPollInterval / 1000}s`);
                 this.log.info(`Health check interval: ${healthCheckInterval}s`);
-                this.log.info(`Stale threshold: ${staleThreshold}s`);
                 this.log.info('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
                 if (streamingStarted) {
                     if (this.kumoConfig.disablePolling) {
@@ -236,16 +236,41 @@ class KumoV3Platform {
         const wasHealthy = this.isStreamingHealthy;
         this.isStreamingHealthy = isHealthy;
         if (wasHealthy && !isHealthy) {
+            if (this.pendingModeChange) {
+                clearTimeout(this.pendingModeChange);
+                this.pendingModeChange = null;
+                this.pendingModeHealthy = null;
+                this.log.debug('Cancelled pending mode change due to new disconnect');
+            }
             this.log.warn('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
             this.log.warn('⚠ STREAMING INTERRUPTED');
             this.log.warn('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
             this.enterDegradedMode();
         }
         if (!wasHealthy && isHealthy) {
-            this.log.info('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-            this.log.info('✓ STREAMING RESUMED');
-            this.log.info('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-            this.exitDegradedMode();
+            if (this.pendingModeHealthy === true) {
+                this.log.debug('Mode change to healthy already pending, waiting for stability...');
+                return;
+            }
+            if (this.pendingModeChange) {
+                clearTimeout(this.pendingModeChange);
+            }
+            this.pendingModeHealthy = true;
+            const hysteresisSec = this.modeChangeHysteresisMs / 1000;
+            this.log.info(`Streaming reconnected - waiting ${hysteresisSec}s for stable connection...`);
+            this.pendingModeChange = setTimeout(() => {
+                this.pendingModeChange = null;
+                this.pendingModeHealthy = null;
+                if (this.isStreamingHealthy) {
+                    this.log.info('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+                    this.log.info('✓ STREAMING RESUMED (stable)');
+                    this.log.info('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+                    this.exitDegradedMode();
+                }
+                else {
+                    this.log.warn('Streaming became unhealthy during stability check, staying in degraded mode');
+                }
+            }, this.modeChangeHysteresisMs);
         }
     }
     enterDegradedMode() {

package/dist/settings.js

@@ -5,6 +5,6 @@ exports.PLATFORM_NAME = 'KumoV3';
 exports.PLUGIN_NAME = 'homebridge-mitsubishi-comfort';
 exports.API_BASE_URL = 'https://app-prod.kumocloud.com/v3';
 exports.SOCKET_BASE_URL = 'https://socket-prod.kumocloud.com';
-exports.TOKEN_REFRESH_INTERVAL = 15 * 60 * 1000;
+exports.TOKEN_REFRESH_INTERVAL = 20 * 60 * 1000;
 exports.POLL_INTERVAL = 30 * 1000;
 exports.APP_VERSION = '3.2.3';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homebridge-mitsubishi-comfort",
-  "version": "1.3.0",
+  "version": "1.3.3",
   "description": "Homebridge plugin for Mitsubishi heat pumps using Kumo Cloud v3 API",
   "author": "burtherman",
   "main": "dist/index.js",