homebridge-tryfi 1.1.0 → 1.2.0

package/src/platform.ts

@@ -9,7 +9,7 @@ import {
 } from 'homebridge';
 import { TryFiAPI } from './api';
 import { TryFiCollarAccessory } from './accessory';
-import { TryFiPlatformConfig } from './types';
+import { TryFiPlatformConfig, TryFiPet } from './types';
 
 /**
  * TryFi Platform Plugin
@@ -25,6 +25,10 @@ export class TryFiPlatform implements DynamicPlatformPlugin {
   public readonly tryfiApi: TryFiAPI;
   public readonly api: TryFiAPI; // Alias for accessory use
   private pollingInterval?: NodeJS.Timeout;
+  
+  // Escape alert hysteresis tracking (in-memory only, resets on restart)
+  private escapeCounters: Map<string, number> = new Map();
+  private quickCheckTimeouts: Map<string, NodeJS.Timeout> = new Map();
 
   constructor(
     public readonly log: Logger,
@@ -161,8 +165,29 @@ export class TryFiPlatform implements DynamicPlatformPlugin {
 
       // Start polling for updates
       this.startPolling();
-    } catch (error) {
-      this.log.error('Failed to discover TryFi devices:', error);
+    } catch (error: any) {
+      // Handle different error types during discovery
+      if (error.response?.status) {
+        const status = error.response.status;
+        
+        // Transient server errors - warn and start polling anyway (will retry)
+        if (status === 502 || status === 503 || status === 504) {
+          this.log.warn(`TryFi API temporarily unavailable (${status}) during startup`);
+          this.log.warn('Will continue to retry during polling');
+          this.startPolling(); // Start polling anyway, will retry
+          return;
+        }
+        
+        // Authentication errors
+        if (status === 401 || status === 403) {
+          this.log.error('Authentication failed - please check your username and password');
+          return;
+        }
+        
+        this.log.error(`Failed to discover TryFi devices (HTTP ${status}):`, error.message);
+      } else {
+        this.log.error('Failed to discover TryFi devices:', error.message || error);
+      }
     }
   }
 
@@ -200,12 +225,148 @@ export class TryFiPlatform implements DynamicPlatformPlugin {
         const accessory = this.collarAccessories.get(pet.petId);
         if (accessory) {
           accessory.updatePetData(pet);
+          
+          // Handle escape alert hysteresis
+          this.handleEscapeDetection(pet);
         }
       }
 
       this.log.debug(`Updated ${pets.length} collar(s)`);
-    } catch (error) {
-      this.log.error('Failed to poll TryFi API:', error);
+    } catch (error: any) {
+      // Handle different error types appropriately
+      if (error.response?.status) {
+        const status = error.response.status;
+        
+        // Transient server errors (502, 503, 504) - just warn and retry next interval
+        if (status === 502 || status === 503 || status === 504) {
+          this.log.warn(`TryFi API temporarily unavailable (${status}), will retry on next poll`);
+          return;
+        }
+        
+        // Authentication errors (401, 403) - try to re-authenticate
+        if (status === 401 || status === 403) {
+          this.log.warn('Authentication expired, attempting to re-login...');
+          try {
+            await this.tryfiApi.login();
+            this.log.info('Successfully re-authenticated with TryFi');
+            // Try polling again immediately after re-auth
+            const allPets = await this.tryfiApi.getPets();
+            const ignoredPets = (this.config.ignoredPets || []).map(name => name.toLowerCase());
+            const pets = allPets.filter(pet => !ignoredPets.includes(pet.name.toLowerCase()));
+            for (const pet of pets) {
+              const accessory = this.collarAccessories.get(pet.petId);
+              if (accessory) {
+                accessory.updatePetData(pet);
+                this.handleEscapeDetection(pet);
+              }
+            }
+            this.log.debug(`Updated ${pets.length} collar(s) after re-auth`);
+          } catch (reAuthError) {
+            this.log.error('Failed to re-authenticate with TryFi:', reAuthError);
+          }
+          return;
+        }
+        
+        // Other HTTP errors
+        this.log.error(`TryFi API error (${status}):`, error.message);
+      } else {
+        // Network errors, timeouts, etc.
+        this.log.error('Failed to poll TryFi API:', error.message || error);
+      }
+    }
+  }
+
+  /**
+   * Handle escape detection with hysteresis (debouncing)
+   * Prevents false alarms from GPS drift by requiring multiple consecutive detections
+   */
+  private handleEscapeDetection(pet: TryFiPet) {
+    // Check if pet is escaped (out of zone AND not with anyone)
+    const isEscaped = (pet.placeName === null && pet.connectedToUser === null);
+    
+    const currentCount = this.escapeCounters.get(pet.petId) || 0;
+    const confirmationsRequired = this.config.escapeConfirmations || 2;
+    
+    if (isEscaped) {
+      // Potential escape detected - increment counter
+      const newCount = currentCount + 1;
+      this.escapeCounters.set(pet.petId, newCount);
+      
+      this.log.debug(
+        `${pet.name} out of zone (${newCount}/${confirmationsRequired} confirmations)`,
+      );
+      
+      if (newCount >= confirmationsRequired) {
+        // Threshold reached - escape confirmed
+        // Accessory will handle the actual alert state update
+        this.log.info(`${pet.name} escape confirmed after ${newCount} check(s)`);
+      } else {
+        // Not confirmed yet - schedule quick re-check
+        this.scheduleQuickCheck(pet.petId, pet.name);
+      }
+    } else {
+      // Pet is safe (in zone OR with someone) - reset counter
+      const hadCount = currentCount > 0;
+      this.escapeCounters.set(pet.petId, 0);
+      this.cancelQuickCheck(pet.petId);
+      
+      if (hadCount) {
+        this.log.debug(`${pet.name} back in safe state, reset escape counter`);
+      }
+    }
+  }
+
+  /**
+   * Schedule a quick check for a specific pet
+   * Used during escape detection to re-verify faster than normal polling
+   */
+  private scheduleQuickCheck(petId: string, petName: string) {
+    // Don't schedule if already scheduled
+    if (this.quickCheckTimeouts.has(petId)) {
+      return;
+    }
+    
+    const interval = (this.config.escapeCheckInterval || 30) * 1000;
+    
+    this.log.debug(`Scheduling quick check for ${petName} in ${interval / 1000}s`);
+    
+    const timeout = setTimeout(async () => {
+      this.log.debug(`Running quick check for ${petName}`);
+      
+      // Remove from timeouts map
+      this.quickCheckTimeouts.delete(petId);
+      
+      // Poll just this one pet
+      try {
+        const allPets = await this.tryfiApi.getPets();
+        const pet = allPets.find(p => p.petId === petId);
+        
+        if (pet) {
+          const accessory = this.collarAccessories.get(petId);
+          if (accessory) {
+            accessory.updatePetData(pet);
+            
+            // Handle escape detection (may schedule another quick check)
+            this.handleEscapeDetection(pet);
+          }
+        }
+      } catch (error: any) {
+        this.log.warn(`Quick check failed for ${petName}:`, error.message || error);
+        // Counter will remain, next normal poll will try again
+      }
+    }, interval);
+    
+    this.quickCheckTimeouts.set(petId, timeout);
+  }
+
+  /**
+   * Cancel any pending quick check for a pet
+   */
+  private cancelQuickCheck(petId: string) {
+    const timeout = this.quickCheckTimeouts.get(petId);
+    if (timeout) {
+      clearTimeout(timeout);
+      this.quickCheckTimeouts.delete(petId);
     }
   }
 
@@ -216,5 +377,11 @@ export class TryFiPlatform implements DynamicPlatformPlugin {
     if (this.pollingInterval) {
       clearInterval(this.pollingInterval);
     }
+    
+    // Cancel all pending quick checks
+    for (const timeout of this.quickCheckTimeouts.values()) {
+      clearTimeout(timeout);
+    }
+    this.quickCheckTimeouts.clear();
   }
 }

package/src/types.ts

@@ -9,6 +9,8 @@ export interface TryFiPlatformConfig extends PlatformConfig {
   pollingInterval?: number; // seconds, default 60
   escapeAlertType?: 'leak' | 'motion'; // default 'leak'
   ignoredPets?: string[]; // pet names to ignore (case-insensitive)
+  escapeConfirmations?: number; // consecutive out-of-zone readings required, default 2
+  escapeCheckInterval?: number; // seconds between quick checks, default 30
 }
 
 /**