homebridge-tryfi 1.1.0

package/src/api.ts

@@ -0,0 +1,409 @@
+import axios, { AxiosInstance } from 'axios';
+import { wrapper } from 'axios-cookiejar-support';
+import { CookieJar } from 'tough-cookie';
+import { Logger } from 'homebridge';
+import {
+  TryFiSession,
+  TryFiPet,
+  GraphQLResponse,
+  CurrentUserResponse,
+} from './types';
+
+/**
+ * TryFi API Client - matches pytryfi implementation exactly
+ */
+export class TryFiAPI {
+  private readonly apiUrl = 'https://api.tryfi.com';
+  private readonly client: AxiosInstance;
+  private readonly jar: CookieJar;
+  private session: TryFiSession | null = null;
+
+  constructor(
+    private readonly username: string,
+    private readonly password: string,
+    private readonly log: Logger,
+  ) {
+    // Create cookie jar to persist cookies like Python requests.Session()
+    this.jar = new CookieJar();
+    
+    // Wrap axios with cookie jar support
+    this.client = wrapper(axios.create({
+      baseURL: this.apiUrl,
+      timeout: 30000,
+      jar: this.jar,
+      withCredentials: true,
+    }));
+  }
+
+  /**
+   * Login using REST API (matches pytryfi)
+   */
+  async login(): Promise<void> {
+    try {
+      const formData = new URLSearchParams();
+      formData.append('email', this.username);
+      formData.append('password', this.password);
+
+      const response = await this.client.post('/auth/login', formData, {
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded',
+        },
+      });
+
+      if (response.data.error) {
+        throw new Error(`Login failed: ${response.data.error.message}`);
+      }
+
+      if (!response.data.userId || !response.data.sessionId) {
+        throw new Error('Login failed: No session data returned');
+      }
+
+      this.session = {
+        userId: response.data.userId,
+        sessionId: response.data.sessionId,
+      };
+
+      // Set JSON header for subsequent GraphQL requests (matches pytryfi.setHeaders())
+      this.client.defaults.headers.common['Content-Type'] = 'application/json';
+
+      this.log.info('Successfully authenticated with TryFi');
+    } catch (error) {
+      this.log.error('Failed to login to TryFi:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Get all pets using EXACT pytryfi query structure
+   */
+  async getPets(): Promise<TryFiPet[]> {
+    await this.ensureAuthenticated();
+
+    // This matches pytryfi's QUERY_CURRENT_USER_FULL_DETAIL + fragments
+    const query = `
+      query {
+        currentUser {
+          __typename
+          id
+          email
+          firstName
+          lastName
+          userHouseholds {
+            __typename
+            household {
+              __typename
+              pets {
+                __typename
+                id
+                name
+                homeCityState
+                gender
+                breed {
+                  __typename
+                  id
+                  name
+                }
+                device {
+                  __typename
+                  id
+                  moduleId
+                  info
+                  operationParams {
+                    __typename
+                    mode
+                    ledEnabled
+                    ledOffAt
+                  }
+                  lastConnectionState {
+                    __typename
+                    date
+                    ... on ConnectedToUser {
+                      user {
+                        __typename
+                        id
+                        firstName
+                        lastName
+                      }
+                    }
+                    ... on ConnectedToBase {
+                      chargingBase {
+                        __typename
+                        id
+                      }
+                    }
+                    ... on ConnectedToCellular {
+                      signalStrengthPercent
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    `;
+
+    try {
+      const response = await this.client.post<GraphQLResponse<CurrentUserResponse>>(
+        '/graphql',
+        { query },
+      );
+
+      if (response.data.errors) {
+        throw new Error(`GraphQL error: ${response.data.errors[0].message}`);
+      }
+
+      if (!response.data.data?.currentUser?.userHouseholds) {
+        return [];
+      }
+
+      // Flatten pets from all households
+      const pets: TryFiPet[] = [];
+      for (const userHousehold of response.data.data.currentUser.userHouseholds) {
+        if (userHousehold.household?.pets) {
+          for (const pet of userHousehold.household.pets) {
+            if (!pet.device) {
+              this.log.warn(`Pet ${pet.name} has no device, skipping`);
+              continue;
+            }
+
+            // Parse device info JSON object
+            const deviceInfo = pet.device.info || {};
+            const batteryPercent = parseInt(deviceInfo.batteryPercent) || 0;
+            const isCharging = deviceInfo.isCharging || false;
+
+            // Get location data for this pet
+            const location = await this.getPetLocation(pet.id);
+
+            // Determine connection status
+            const connectionState = pet.device.lastConnectionState;
+            const isCharging2 = connectionState?.__typename === 'ConnectedToBase';
+            const connectedToUser = 
+              connectionState?.__typename === 'ConnectedToUser'
+                ? (connectionState as any).user?.firstName || null
+                : null;
+
+            pets.push({
+              petId: pet.id,
+              name: pet.name,
+              breed: pet.breed?.name || 'Unknown',
+              moduleId: pet.device.moduleId,
+              batteryPercent,
+              isCharging: isCharging || isCharging2,
+              ledEnabled: pet.device.operationParams?.ledEnabled || false,
+              mode: pet.device.operationParams?.mode || 'NORMAL',
+              connectedToUser,
+              ...location,
+            });
+          }
+        }
+      }
+
+      this.log.debug(`Retrieved ${pets.length} pet(s) from TryFi`);
+      return pets;
+    } catch (error) {
+      this.log.error('Failed to get pets:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Get pet location - matches pytryfi's getCurrentPetLocation
+   */
+  private async getPetLocation(petId: string): Promise<{
+    latitude: number;
+    longitude: number;
+    areaName: string | null;
+    placeName: string | null;
+    placeAddress: string | null;
+  }> {
+    const query = `
+      query {
+        pet(id: "${petId}") {
+          ongoingActivity {
+            __typename
+            start
+            areaName
+            ... on OngoingWalk {
+              positions {
+                __typename
+                date
+                position {
+                  __typename
+                  latitude
+                  longitude
+                }
+              }
+            }
+            ... on OngoingRest {
+              position {
+                __typename
+                latitude
+                longitude
+              }
+              place {
+                __typename
+                id
+                name
+                address
+              }
+            }
+          }
+        }
+      }
+    `;
+
+    try {
+      const response = await this.client.post<GraphQLResponse<any>>(
+        '/graphql',
+        { query },
+      );
+
+      if (response.data.errors) {
+        this.log.warn(`Failed to get location for pet ${petId}:`, response.data.errors[0].message);
+        return {
+          latitude: 0,
+          longitude: 0,
+          areaName: null,
+          placeName: null,
+          placeAddress: null,
+        };
+      }
+
+      const activity = response.data.data?.pet?.ongoingActivity;
+      if (!activity) {
+        return {
+          latitude: 0,
+          longitude: 0,
+          areaName: null,
+          placeName: null,
+          placeAddress: null,
+        };
+      }
+
+      const areaName = activity.areaName || null;
+      let latitude = 0;
+      let longitude = 0;
+      let placeName = null;
+      let placeAddress = null;
+
+      if (activity.__typename === 'OngoingRest') {
+        latitude = activity.position?.latitude || 0;
+        longitude = activity.position?.longitude || 0;
+        placeName = activity.place?.name || null;
+        placeAddress = activity.place?.address || null;
+      } else if (activity.__typename === 'OngoingWalk' && activity.positions?.length > 0) {
+        const lastPosition = activity.positions[activity.positions.length - 1];
+        latitude = lastPosition.position?.latitude || 0;
+        longitude = lastPosition.position?.longitude || 0;
+      }
+
+      return { latitude, longitude, areaName, placeName, placeAddress };
+    } catch (error) {
+      this.log.warn(`Failed to get location for pet ${petId}:`, error);
+      return {
+        latitude: 0,
+        longitude: 0,
+        areaName: null,
+        placeName: null,
+        placeAddress: null,
+      };
+    }
+  }
+
+  /**
+   * Set LED on/off - matches pytryfi's turnOnOffLed
+   */
+  async setLedState(moduleId: string, ledEnabled: boolean): Promise<void> {
+    await this.ensureAuthenticated();
+
+    const mutation = `
+      mutation UpdateDeviceOperationParams($input: UpdateDeviceOperationParamsInput!) {
+        updateDeviceOperationParams(input: $input) {
+          __typename
+          id
+          moduleId
+          operationParams {
+            __typename
+            mode
+            ledEnabled
+            ledOffAt
+          }
+        }
+      }
+    `;
+
+    try {
+      const response = await this.client.post('/graphql', {
+        query: mutation,
+        variables: {
+          input: {
+            moduleId,
+            ledEnabled,
+          },
+        },
+      });
+
+      if (response.data.errors) {
+        throw new Error(`Failed to set LED: ${response.data.errors[0].message}`);
+      }
+
+      this.log.debug(`Set LED ${ledEnabled ? 'on' : 'off'} for module ${moduleId}`);
+    } catch (error) {
+      this.log.error('Failed to set LED state:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Set Lost Dog Mode - matches pytryfi's setLostDogMode
+   */
+  async setLostDogMode(moduleId: string, isLost: boolean): Promise<void> {
+    await this.ensureAuthenticated();
+
+    const mode = isLost ? 'LOST_DOG' : 'NORMAL';
+
+    const mutation = `
+      mutation UpdateDeviceOperationParams($input: UpdateDeviceOperationParamsInput!) {
+        updateDeviceOperationParams(input: $input) {
+          __typename
+          id
+          moduleId
+          operationParams {
+            __typename
+            mode
+            ledEnabled
+            ledOffAt
+          }
+        }
+      }
+    `;
+
+    try {
+      const response = await this.client.post('/graphql', {
+        query: mutation,
+        variables: {
+          input: {
+            moduleId,
+            mode,
+          },
+        },
+      });
+
+      if (response.data.errors) {
+        throw new Error(`Failed to set lost mode: ${response.data.errors[0].message}`);
+      }
+
+      this.log.info(`Set Lost Dog Mode ${isLost ? 'ON' : 'OFF'} for module ${moduleId}`);
+    } catch (error) {
+      this.log.error('Failed to set lost dog mode:', error);
+      throw error;
+    }
+  }
+
+  private async ensureAuthenticated(): Promise<void> {
+    if (!this.session) {
+      await this.login();
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+import { API } from 'homebridge';
+import { TryFiPlatform } from './platform';
+import { PLATFORM_NAME, PLUGIN_NAME } from './settings';
+
+/**
+ * This method registers the platform with Homebridge
+ */
+export = (api: API) => {
+  api.registerPlatform(PLUGIN_NAME, PLATFORM_NAME, TryFiPlatform);
+};

package/src/platform.ts

@@ -0,0 +1,220 @@
+import {
+  API,
+  DynamicPlatformPlugin,
+  Logger,
+  PlatformAccessory,
+  PlatformConfig,
+  Service,
+  Characteristic,
+} from 'homebridge';
+import { TryFiAPI } from './api';
+import { TryFiCollarAccessory } from './accessory';
+import { TryFiPlatformConfig } from './types';
+
+/**
+ * TryFi Platform Plugin
+ */
+export class TryFiPlatform implements DynamicPlatformPlugin {
+  public readonly Service: typeof Service;
+  public readonly Characteristic: typeof Characteristic;
+
+  public readonly config: TryFiPlatformConfig;
+  public readonly accessories: PlatformAccessory[] = [];
+  public readonly collarAccessories: Map<string, TryFiCollarAccessory> = new Map();
+
+  public readonly tryfiApi: TryFiAPI;
+  public readonly api: TryFiAPI; // Alias for accessory use
+  private pollingInterval?: NodeJS.Timeout;
+
+  constructor(
+    public readonly log: Logger,
+    config: PlatformConfig,
+    public readonly homebridgeApi: API,
+  ) {
+    this.Service = this.homebridgeApi.hap.Service;
+    this.Characteristic = this.homebridgeApi.hap.Characteristic;
+
+    // Cast config to our platform config type
+    this.config = config as TryFiPlatformConfig;
+
+    // Validate config
+    if (!this.config.username || !this.config.password) {
+      this.log.error('TryFi username and password are required in config');
+      throw new Error('Missing required config');
+    }
+
+    // Create API client
+    this.tryfiApi = new TryFiAPI(this.config.username, this.config.password, log);
+    this.api = this.tryfiApi; // Alias for accessory use
+
+    this.log.debug('Finished initializing platform:', config.name);
+
+    // When this event is fired it means Homebridge has restored all cached accessories
+    this.homebridgeApi.on('didFinishLaunching', () => {
+      log.debug('Executed didFinishLaunching callback');
+      this.discoverDevices();
+    });
+  }
+
+  /**
+   * This function is invoked when homebridge restores cached accessories from disk at startup.
+   */
+  configureAccessory(accessory: PlatformAccessory) {
+    this.log.info('Loading accessory from cache:', accessory.displayName);
+    this.accessories.push(accessory);
+  }
+
+  /**
+   * Discover TryFi collars and create accessories
+   */
+  async discoverDevices() {
+    try {
+      // Login and get pets
+      await this.tryfiApi.login();
+      const allPets = await this.tryfiApi.getPets();
+
+      // Filter out ignored pets (case-insensitive)
+      const ignoredPets = (this.config.ignoredPets || []).map(name => name.toLowerCase());
+      const pets = allPets.filter(pet => !ignoredPets.includes(pet.name.toLowerCase()));
+
+      if (ignoredPets.length > 0) {
+        const ignoredCount = allPets.length - pets.length;
+        if (ignoredCount > 0) {
+          this.log.info(`Ignoring ${ignoredCount} pet(s) based on configuration`);
+        }
+      }
+
+      this.log.info(`Discovered ${pets.length} TryFi collar(s)`);
+
+      // Track discovered pet IDs
+      const discoveredPetIds = new Set<string>();
+
+      for (const pet of pets) {
+        discoveredPetIds.add(pet.petId);
+
+        // Generate unique ID for this accessory
+        const uuid = this.homebridgeApi.hap.uuid.generate(pet.petId);
+
+        // Check if accessory already exists
+        const existingAccessory = this.accessories.find(
+          (accessory) => accessory.UUID === uuid,
+        );
+
+        if (existingAccessory) {
+          // Restore existing accessory
+          this.log.info('Restoring existing accessory from cache:', pet.name);
+          existingAccessory.context.pet = pet;
+
+          // Create collar accessory handler
+          const collarAccessory = new TryFiCollarAccessory(
+            this,
+            existingAccessory,
+            pet,
+          );
+          this.collarAccessories.set(pet.petId, collarAccessory);
+
+          // Update reachability
+          this.homebridgeApi.updatePlatformAccessories([existingAccessory]);
+        } else {
+          // Create new accessory
+          this.log.info('Adding new accessory:', pet.name);
+
+          const accessory = new this.homebridgeApi.platformAccessory(pet.name, uuid);
+          accessory.context.pet = pet;
+
+          // Create collar accessory handler
+          const collarAccessory = new TryFiCollarAccessory(this, accessory, pet);
+          this.collarAccessories.set(pet.petId, collarAccessory);
+
+          // Register new accessory
+          this.homebridgeApi.registerPlatformAccessories('homebridge-tryfi', 'TryFi', [
+            accessory,
+          ]);
+          this.accessories.push(accessory);
+        }
+      }
+
+      // Remove accessories for pets that no longer exist
+      const accessoriesToRemove = this.accessories.filter(
+        (accessory) => !discoveredPetIds.has(accessory.context.pet?.petId),
+      );
+
+      if (accessoriesToRemove.length > 0) {
+        this.log.info(
+          `Removing ${accessoriesToRemove.length} accessory(ies) for deleted pets`,
+        );
+        this.homebridgeApi.unregisterPlatformAccessories(
+          'homebridge-tryfi',
+          'TryFi',
+          accessoriesToRemove,
+        );
+
+        // Remove from our tracking
+        for (const accessory of accessoriesToRemove) {
+          const index = this.accessories.indexOf(accessory);
+          if (index > -1) {
+            this.accessories.splice(index, 1);
+          }
+          this.collarAccessories.delete(accessory.context.pet?.petId);
+        }
+      }
+
+      // Start polling for updates
+      this.startPolling();
+    } catch (error) {
+      this.log.error('Failed to discover TryFi devices:', error);
+    }
+  }
+
+  /**
+   * Start polling TryFi API for updates
+   */
+  private startPolling() {
+    const pollingInterval = (this.config.pollingInterval || 60) * 1000;
+    this.log.info(`Starting polling every ${pollingInterval / 1000} seconds`);
+
+    // Clear any existing interval
+    if (this.pollingInterval) {
+      clearInterval(this.pollingInterval);
+    }
+
+    // Poll immediately, then at intervals
+    this.pollDevices();
+    this.pollingInterval = setInterval(() => {
+      this.pollDevices();
+    }, pollingInterval);
+  }
+
+  /**
+   * Poll TryFi API for device updates
+   */
+  private async pollDevices() {
+    try {
+      const allPets = await this.tryfiApi.getPets();
+
+      // Filter out ignored pets (case-insensitive)
+      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.log.debug(`Updated ${pets.length} collar(s)`);
+    } catch (error) {
+      this.log.error('Failed to poll TryFi API:', error);
+    }
+  }
+
+  /**
+   * Stop polling when platform is shutting down
+   */
+  shutdown() {
+    if (this.pollingInterval) {
+      clearInterval(this.pollingInterval);
+    }
+  }
+}

package/src/settings.ts

@@ -0,0 +1,9 @@
+/**
+ * This is the name of the platform that users will use to register the plugin in the Homebridge config.json
+ */
+export const PLATFORM_NAME = 'TryFi';
+
+/**
+ * This must match the name of your plugin as defined the package.json
+ */
+export const PLUGIN_NAME = 'homebridge-tryfi';