homebridge-tsvesync 1.1.2 → 1.3.4

package/src/platform.ts

@@ -6,6 +6,7 @@ import { BaseAccessory } from './accessories/base.accessory';
 import { PluginLogger } from './utils/logger';
 import { createRateLimitedVeSync } from './utils/api-proxy';
 import { PlatformConfig as TSVESyncPlatformConfig } from './types/device.types';
+import { FileSessionStore, decodeJwtTimestampsLocal } from './utils/session-store';
 
 /**
  * HomebridgePlatform
@@ -24,6 +25,10 @@ export class TSVESyncPlatform implements DynamicPlatformPlugin {
   
   private client!: VeSync;
   private deviceUpdateInterval?: NodeJS.Timeout;
+  private refreshTimer?: NodeJS.Timeout;
+  private refreshInProgress = false;
+  private scheduledExpMs: number | null = null;
+  private refreshRemainingMs: number | null = null;
   private readonly updateInterval!: number;
   private readonly debug!: boolean;
   private lastLoginAttempt: Date = new Date(0);
@@ -32,6 +37,7 @@ export class TSVESyncPlatform implements DynamicPlatformPlugin {
   private initializationResolver!: () => void;
   private isInitialized = false;
   private readonly logger!: PluginLogger;
+  private readonly sessionStore!: FileSessionStore;
   // VeSync JWT tokens are valid for 30 days (verified by decoding the JWT)
   // We'll refresh at 25 days to ensure we never hit expiration
   private readonly TOKEN_EXPIRY = 25 * 24 * 60 * 60 * 1000; // 25 days in milliseconds
@@ -60,6 +66,9 @@ export class TSVESyncPlatform implements DynamicPlatformPlugin {
       return;
     }
 
+    // Prepare session store
+    this.sessionStore = new FileSessionStore(this.api.user.storagePath(), this.logger);
+
     // Initialize VeSync client with all configuration
     this.client = createRateLimitedVeSync(
       config.username,
@@ -73,6 +82,10 @@ export class TSVESyncPlatform implements DynamicPlatformPlugin {
       { 
         countryCode: config.countryCode,
         quotaManagement: config.quotaManagement || { enabled: true } 
+      },
+      {
+        store: this.sessionStore,
+        onTokenChange: (s) => this.onTokenChange(s)
       }
     );
 
@@ -91,6 +104,29 @@ export class TSVESyncPlatform implements DynamicPlatformPlugin {
       this.logger.debug('Executed didFinishLaunching callback');
 
       try {
+        // Try to hydrate session from disk before any login
+        const session = await this.sessionStore.load();
+        if (session) {
+          try {
+            if ((session as any).username && (session as any).username !== this.config.username) {
+              this.logger.info('Found persisted session for a different account; ignoring persisted session.');
+            } else {
+              this.hydrateSessionCompat(session);
+              const ts = decodeJwtTimestampsLocal(session.token);
+              // Use actual token issuance time if available to avoid overextending lifetime
+              this.lastTokenRefresh = ts?.iat ? new Date(ts.iat * 1000) : new Date();
+              const expStr = ts?.exp ? new Date(ts.exp * 1000).toISOString() : 'unknown';
+              this.logger.info(`Reusing persisted VeSync session. Token exp: ${expStr}`);
+              // Schedule a proactive refresh before expiry
+              this.scheduleProactiveRefreshFromToken(session.token);
+            }
+          } catch (e: any) {
+            this.logger.debug(`Failed to hydrate persisted session, will login fresh: ${e?.message || e}`);
+          }
+        } else {
+          this.logger.debug('No persisted VeSync session available; will authenticate.');
+        }
+
         // Initialize platform
         await this.initializePlatform();
         
@@ -116,6 +152,9 @@ export class TSVESyncPlatform implements DynamicPlatformPlugin {
       if (this.deviceUpdateInterval) {
         clearInterval(this.deviceUpdateInterval);
       }
+      if (this.refreshTimer) {
+        clearTimeout(this.refreshTimer);
+      }
     });
   }
 
@@ -146,12 +185,15 @@ export class TSVESyncPlatform implements DynamicPlatformPlugin {
    */
   private async initializePlatform(): Promise<void> {
     try {
-      // Try to login first
-      if (!await this.ensureLogin()) {
-        throw new Error('Failed to login to VeSync API');
+      // If we don't have a token/account yet, perform a login once. Otherwise,
+      // trust the persisted token and let the library re-login only if the API rejects it.
+      if (!(this.client as any).token || !(this.client as any).accountId) {
+        if (!await this.ensureLogin()) {
+          throw new Error('Failed to login to VeSync API');
+        }
       }
 
-      // Get devices from API
+      // Get devices from API (will re-login on 401/419 only)
       await this.client.update();
 
       // Discover devices
@@ -255,6 +297,26 @@ export class TSVESyncPlatform implements DynamicPlatformPlugin {
         // Reset backoff and update token refresh time on successful login
         this.loginBackoffTime = 10000;
         this.lastTokenRefresh = new Date();
+        // Best-effort: persist the fresh session immediately in case callbacks fail
+        try {
+          const token = (this.client as any).token as string | null;
+          const accountId = (this.client as any).accountId as string | null;
+          const region = (this.client as any).region as string | null;
+          const apiBaseUrl = (this.client as any).apiBaseUrl as string | null;
+          if (token && accountId && region && apiBaseUrl) {
+            const ts = decodeJwtTimestampsLocal(token);
+            await this.sessionStore.save({
+              token,
+              accountId,
+              region,
+              apiBaseUrl,
+              issuedAt: ts?.iat ?? null,
+              expiresAt: ts?.exp ?? null,
+              lastValidatedAt: Date.now(),
+              username: this.config.username,
+            } as any);
+          }
+        } catch {/* ignore */}
         isLoggedIn = true;
         return true;
       } catch (error) {
@@ -282,7 +344,162 @@ export class TSVESyncPlatform implements DynamicPlatformPlugin {
    * Update device states periodically
    */
   private async updateDeviceStates() {
-    await this.discoverDevices();
+    if (this.refreshInProgress) {
+      return;
+    }
+
+    this.refreshInProgress = true;
+
+    try {
+      await this.discoverDevices();
+
+      const syncTasks = Array.from(this.deviceAccessories.values()).map(async accessory => {
+        try {
+          await accessory.syncDeviceState();
+        } catch (error) {
+          this.logger.warn('Failed to sync device state during scheduled refresh', error as Error);
+        }
+      });
+
+      await Promise.all(syncTasks);
+    } finally {
+      this.refreshInProgress = false;
+    }
+  }
+
+  /**
+   * Handle token updates from the library
+   */
+  private onTokenChange(session: { token: string } | undefined) {
+    if (!session?.token) return;
+    this.scheduleProactiveRefreshFromToken(session.token);
+    // Persist with username to ensure correct account reuse
+    try {
+      void this.sessionStore.save({ ...(session as any), username: this.config.username } as any);
+    } catch { /* noop */ }
+  }
+
+  /**
+   * Backward-compatible session hydration when using older tsvesync versions
+   */
+  private hydrateSessionCompat(session: { token: string; accountId: string; countryCode?: string | null; apiBaseUrl?: string; region?: string }) {
+    const client: any = this.client as any;
+    if (typeof client.hydrateSession === 'function') {
+      client.hydrateSession(session);
+      return;
+    }
+    // Fallback: set core fields directly
+    client.token = session.token;
+    client.accountId = session.accountId;
+    client.countryCode = session.countryCode ?? null;
+    if (session.apiBaseUrl) {
+      client.apiBaseUrl = session.apiBaseUrl;
+    }
+    if (session.region) {
+      try { client.region = session.region; } catch { /* ignore */ }
+    }
+    client.enabled = true;
+  }
+
+  /**
+   * Schedule a proactive token refresh before JWT expiry
+   */
+  private scheduleProactiveRefreshFromToken(token: string) {
+    try {
+      const ts = decodeJwtTimestampsLocal(token);
+      if (!ts?.exp) {
+        return; // Cannot schedule without exp
+      }
+      const now = Date.now();
+      const expMs = ts.exp * 1000;
+      const msToExpiry = expMs - now;
+      
+      // If we already have a timer for this exact token expiration, skip
+      if (this.scheduledExpMs === expMs && this.refreshTimer) {
+        return;
+      }
+      if (msToExpiry <= 0) {
+        // Already expired; trigger immediate login in background
+        void this.ensureLogin(true);
+        return;
+      }
+
+      // Schedule policy to prevent thrash and avoid frequent logins:
+      // - If >7d left: refresh 5d before expiry
+      // - If 1–7d left: refresh 12h before expiry
+      // - If 1–24h left: refresh 1h before expiry
+      // - If <1h left: do not proactively refresh; rely on library's 401-triggered re-login
+      const ONE_HOUR = 60 * 60 * 1000;
+      const TWELVE_HOURS = 12 * ONE_HOUR;
+      const FIVE_DAYS = 5 * 24 * ONE_HOUR;
+      const SEVEN_DAYS = 7 * 24 * ONE_HOUR;
+
+      let refreshIn: number;
+      if (msToExpiry > SEVEN_DAYS) {
+        refreshIn = msToExpiry - FIVE_DAYS;
+      } else if (msToExpiry > 24 * ONE_HOUR) {
+        refreshIn = msToExpiry - TWELVE_HOURS;
+      } else if (msToExpiry > ONE_HOUR) {
+        refreshIn = msToExpiry - ONE_HOUR;
+      } else {
+        // Too close to expiry; avoid hammering login — let 401 path handle it
+        this.logger.debug('Token near expiry (<1h). Skipping proactive refresh; relying on auto re-login.');
+        return;
+      }
+
+      // Safety floor: never schedule earlier than 30 minutes from now
+      refreshIn = Math.max(refreshIn, 30 * 60 * 1000);
+
+      if (this.refreshTimer) {
+        clearTimeout(this.refreshTimer);
+      }
+      this.scheduledExpMs = expMs;
+      // Handle Node.js setTimeout max delay (~24.8 days). Chain timers when needed.
+      const MAX_DELAY = 0x7fffffff; // 2,147,483,647 ms
+      if (refreshIn > MAX_DELAY) {
+        this.refreshRemainingMs = refreshIn - MAX_DELAY;
+        this.logger.debug('Proactive refresh scheduled beyond setTimeout max; chaining timers.');
+        this.refreshTimer = setTimeout(() => this.chainRefreshTimer(), MAX_DELAY);
+      } else {
+        this.refreshRemainingMs = 0;
+        this.refreshTimer = setTimeout(async () => {
+          if (this.refreshInProgress) {
+            this.logger.debug('Proactive refresh already in progress; skipping.');
+            return;
+          }
+          this.refreshInProgress = true;
+          this.logger.debug('Proactively refreshing VeSync session before token expiry');
+          try {
+            await this.ensureLogin(true);
+          } finally {
+            this.refreshInProgress = false;
+          }
+        }, refreshIn);
+      }
+
+      const hours = Math.round(refreshIn / (60 * 60 * 1000));
+      this.logger.debug(`Scheduled proactive token refresh in ~${hours}h`);
+    } catch (e) {
+      // Best-effort scheduling; ignore errors
+    }
+  }
+
+  private chainRefreshTimer() {
+    if (!this.refreshRemainingMs || this.refreshRemainingMs <= 0) {
+      // Final hop: trigger refresh now
+      if (this.refreshInProgress) {
+        this.logger.debug('Proactive refresh already in progress; skipping.');
+        return;
+      }
+      this.refreshInProgress = true;
+      this.logger.debug('Proactively refreshing VeSync session before token expiry');
+      void this.ensureLogin(true).finally(() => { this.refreshInProgress = false; });
+      return;
+    }
+    const MAX_DELAY = 0x7fffffff;
+    const hop = Math.min(this.refreshRemainingMs, MAX_DELAY);
+    this.refreshRemainingMs -= hop;
+    this.refreshTimer = setTimeout(() => this.chainRefreshTimer(), hop);
   }
 
   /**
@@ -342,10 +559,7 @@ export class TSVESyncPlatform implements DynamicPlatformPlugin {
   async discoverDevices() {
     this.logger.debug('Discovering devices');
     try {
-      // Try to login first
-      if (!await this.ensureLogin()) {
-        return;
-      }
+      // Do not force login; rely on library to re-login only if needed
 
       let retryCount = 0;
       let success = false;

package/src/types/device.types.ts

@@ -22,6 +22,7 @@ export interface VeSyncDeviceWithPower extends VeSyncBaseDevice {
   deviceStatus: string;
   turnOn(): Promise<boolean>;
   turnOff(): Promise<boolean>;
+  getDetails?: (...args: any[]) => any;
 }
 
 export interface VeSyncDeviceWithBrightness extends VeSyncDeviceWithPower {
@@ -84,8 +85,25 @@ export interface VeSyncFan extends VeSyncDeviceWithPower, VeSyncDeviceWithSpeed,
   setMode(mode: 'normal' | 'auto' | 'sleep' | 'turbo'): Promise<boolean>;
 }
 
+export interface VeSyncDimmerSwitch extends VeSyncDeviceWithBrightness {
+  rgbLightStatus: string;
+  indicatorLightStatus: string;
+  rgbLightValue: {
+    red: number;
+    green: number;
+    blue: number;
+  };
+  rgbColorSet(red: number, green: number, blue: number): Promise<boolean>;
+  rgbColorOn(): Promise<boolean>;
+  rgbColorOff(): Promise<boolean>;
+  indicatorLightOn(): Promise<boolean>;
+  indicatorLightOff(): Promise<boolean>;
+}
+
 export interface VeSyncBulb extends VeSyncDeviceWithPower, VeSyncDeviceWithBrightness, VeSyncDeviceWithColor {}
 
+export type VeSyncLightDevice = VeSyncBulb | VeSyncDimmerSwitch;
+
 export interface VeSyncOutlet extends VeSyncDeviceWithPower {
   power?: number;
   voltage?: number;

package/src/utils/api-proxy.ts

@@ -200,7 +200,7 @@ const createRateLimitedProxy = (target: any, rateLimiter: RateLimiter, deviceId?
       // Methods that bypass all rate limiting and debouncing
       const bypassMethods = [
         // Getters and internal methods
-        'get', 'getService', 'getCharacteristic',
+        'get', 'getService', 'getCharacteristic', 'hydrateSession',
         // State accessors
         'deviceStatus', 'speed', 'brightness', 'colorTemp',
         'mode', 'filterLife', 'airQuality', 'airQualityValue', 'screenStatus',
@@ -258,6 +258,10 @@ export const createRateLimitedVeSync = (
       bufferPercentage?: number;
       priorityMethods?: string[];
     }
+  },
+  session?: {
+    store?: any;
+    onTokenChange?: (s: any) => void;
   }
 ): VeSync => {
   // Use the new options object pattern for VeSync constructor
@@ -267,7 +271,9 @@ export const createRateLimitedVeSync = (
     apiUrl: apiUrl,
     customLogger: customLogger,
     excludeConfig: exclusions,
-    countryCode: config?.countryCode || 'US'  // Default to US
+    countryCode: config?.countryCode || 'US',  // Default to US
+    sessionStore: session?.store,
+    onTokenChange: session?.onTokenChange
   });
   const logger = customLogger || new PluginLogger(console as any, debug || false);
   

package/src/utils/device-factory.ts

@@ -9,11 +9,12 @@ import { OutletAccessory } from '../accessories/outlet.accessory';
 import { SwitchAccessory } from '../accessories/switch.accessory';
 import { BaseAccessory } from '../accessories/base.accessory';
 import { AirQualitySensorAccessory } from '../accessories/air-quality-sensor.accessory';
-import { 
+import {
   VeSyncAirPurifier,
   VeSyncHumidifier,
   VeSyncFan,
   VeSyncBulb,
+  VeSyncDimmerSwitch,
   VeSyncOutlet,
   VeSyncSwitch
 } from '../types/device.types';
@@ -38,7 +39,9 @@ const OUTLET_MODELS = [
   'ESW10-USA', 'wifi-switch-1.3'
 ];
 
-const SWITCH_MODELS = ['ESWD16', 'ESWL01', 'ESWL03'];
+const SWITCH_MODELS = ['ESWL01', 'ESWL03'];
+
+const DIMMER_MODELS = ['ESWD16'];
 
 export class DeviceFactory {
   private static modelMatches(deviceType: string, models: string[]): boolean {
@@ -66,6 +69,10 @@ export class DeviceFactory {
     return deviceType.startsWith('ESL') || deviceType === 'XYD0001';
   }
 
+  private static isDimmer(deviceType: string): boolean {
+    return this.modelMatches(deviceType, DIMMER_MODELS);
+  }
+
   private static isOutlet(deviceType: string): boolean {
     return this.modelMatches(deviceType, OUTLET_MODELS);
   }
@@ -96,6 +103,11 @@ export class DeviceFactory {
       return new FanAccessory(platform, accessory, device as VeSyncFan);
     }
 
+    // Dimmers
+    if (this.isDimmer(deviceType)) {
+      return new LightAccessory(platform, accessory, device as VeSyncDimmerSwitch);
+    }
+
     // Bulbs
     if (this.isBulb(deviceType)) {
       return new LightAccessory(platform, accessory, device as VeSyncBulb);
@@ -131,7 +143,7 @@ export class DeviceFactory {
       return Categories.FAN;
     }
 
-    if (this.isBulb(type)) {
+    if (this.isDimmer(type) || this.isBulb(type)) {
       return Categories.LIGHTBULB;
     }
 
@@ -179,4 +191,4 @@ export class DeviceFactory {
     platform.log.debug(`Not creating AQ sensor for ${device.deviceName} - no air quality support detected`);
     return null;
   }
-} 
+} 

package/src/utils/session-store.ts

@@ -0,0 +1,92 @@
+import fs from 'fs';
+import path from 'path';
+import { PluginLogger } from './logger';
+
+export interface PluginSession {
+  token: string;
+  accountId: string;
+  countryCode?: string | null;
+  region: string;
+  apiBaseUrl: string;
+  authFlowUsed?: 'legacy' | 'new';
+  issuedAt?: number | null;
+  expiresAt?: number | null;
+  lastValidatedAt?: number | null;
+  libraryVersion?: string;
+  // Optional: helps ensure session matches configured Homebridge account
+  username?: string;
+}
+
+export class FileSessionStore {
+  private readonly dir: string;
+  private readonly file: string;
+
+  constructor(basePath: string, private readonly logger: PluginLogger) {
+    this.dir = path.join(basePath, 'tsvesync');
+    this.file = path.join(this.dir, 'session.json');
+  }
+
+  async load(): Promise<PluginSession | null> {
+    try {
+      await fs.promises.mkdir(this.dir, { recursive: true });
+      const data = await fs.promises.readFile(this.file, 'utf8');
+      const session = JSON.parse(data) as PluginSession;
+      if (!session || !session.token || !session.accountId) return null;
+      try {
+        const expSec = session.expiresAt && session.expiresAt > 1e11 ? Math.floor(session.expiresAt / 1000) : session.expiresAt;
+        const exp = expSec ? new Date(expSec * 1000).toISOString() : 'unknown';
+        this.logger.debug(`Loaded persisted session from ${this.file} (exp: ${exp})`);
+      } catch {}
+      return session;
+    } catch (e: any) {
+      if (e?.code === 'ENOENT') {
+        this.logger.debug(`No persisted session found at ${this.file}`);
+      } else {
+        this.logger.debug(`Session load error: ${e?.message || e}`);
+      }
+      return null;
+    }
+  }
+
+  async save(session: PluginSession): Promise<void> {
+    try {
+      await fs.promises.mkdir(this.dir, { recursive: true });
+      const tmp = this.file + '.tmp';
+      await fs.promises.writeFile(tmp, JSON.stringify(session), { encoding: 'utf8', mode: 0o600 });
+      await fs.promises.rename(tmp, this.file);
+      try { await fs.promises.chmod(this.file, 0o600); } catch { /* best effort */ }
+      try {
+        const expSec = session.expiresAt && session.expiresAt > 1e11 ? Math.floor(session.expiresAt / 1000) : session.expiresAt;
+        const exp = expSec ? new Date(expSec * 1000).toISOString() : 'unknown';
+        this.logger.debug(`Persisted session to ${this.file} (exp: ${exp})`);
+      } catch {}
+    } catch (e: any) {
+      this.logger.debug(`Session save error: ${e?.message || e}`);
+    }
+  }
+
+  async clear(): Promise<void> {
+    try {
+      await fs.promises.unlink(this.file);
+    } catch (e: any) {
+      if (e?.code !== 'ENOENT') {
+        this.logger.debug(`Session clear error: ${e?.message || e}`);
+      }
+    }
+  }
+}
+
+export function decodeJwtTimestampsLocal(token: string): { iat?: number; exp?: number } | null {
+  try {
+    const parts = token.split('.');
+    if (parts.length !== 3) return null;
+    const payload = JSON.parse(Buffer.from(parts[1].replace(/-/g, '+').replace(/_/g, '/'), 'base64').toString('utf8'));
+    let iat = typeof payload.iat === 'number' ? payload.iat : undefined;
+    let exp = typeof payload.exp === 'number' ? payload.exp : undefined;
+    if (iat && iat > 1e11) iat = Math.floor(iat / 1000);
+    if (exp && exp > 1e11) exp = Math.floor(exp / 1000);
+    return { iat, exp };
+  } catch {
+    return null;
+  }
+}