@phystack/hub-device 4.4.30

package/src/index.ts

@@ -0,0 +1,1228 @@
+import { Socket, SocketOptions, ManagerOptions } from 'socket.io-client';
+import { getSocketIOWithProxy } from '@phystack/socket.io-proxy';
+import getStorage from './storage';
+import getSysinfo, { isTizen } from './sysinfo';
+import getDeviceIdentifier from './utilities/get-device-identifier.utility';
+import getHubCredentials from './utilities/get-hub-credentials.utility';
+import getProvisioningCode from './utilities/get-provisioning-code.utility';
+import {
+  DeviceIp,
+  DeviceStatus,
+  DeviceTwinReportedProperties,
+  DeviceTwinResponse,
+  EdgeTwinReportedProperties,
+  ScreenTwinReportedProperties,
+  TwinResponse,
+  TwinStatusEnum,
+  TwinTypeEnum,
+  PeripheralTwinReportedProperties,
+} from './types/twin.types';
+import { Job } from './types/job.types';
+import path from 'path';
+import fs from 'fs';
+import { Mutex } from 'async-mutex';
+
+export type MyIoOptions = Partial<ManagerOptions & SocketOptions>;
+interface EventPayload<T = any> {
+  twinId?: string;
+  deviceId?: string;
+  status?: TwinStatusEnum;
+  data?: T;
+}
+
+interface MigratedCredentials {
+  deviceId: string;
+  accessKey: string;
+  deviceSerial: string;
+  phyhubUrl: string;
+  region: string;
+}
+
+enum PhyHubResponseStatus {
+  success = 'success',
+  error = 'error',
+}
+
+const logger = console;
+
+function getVersion(): string {
+  const pkgPath = path.resolve(__dirname, '../package.json');
+  try {
+    const content = fs.readFileSync(pkgPath, 'utf-8');
+    const pkg = JSON.parse(content);
+    return pkg.version || 'N/A';
+  } catch (error) {
+    console.error('Failed to read version from package.json:', error);
+    return 'N/A';
+  }
+}
+
+const phyhubDeviceProvisioningBaseUrls: {[env: string]: string} = {
+  LOCAL: 'https://phyhub-prov.dev.omborigrid.net/api',
+  DEV: 'https://phyhub-prov.dev.omborigrid.net/api',
+  QA: 'https://phyhub-prov.qa.omborigrid.net/api',
+  PROD: 'https://phyhub-prov.eu.omborigrid.net/api',
+};
+
+let phyHubSingleton: HubDevice | null = null;
+
+export const connectToPhyHub = async (
+  gridEnv: string = 'PROD',
+  osVersion: string = 'N/A',
+  migratedCredentials: MigratedCredentials | undefined = undefined
+) => {
+  const storage = await getStorage();
+  let deviceId = await storage.get('deviceId');
+  let accessKey = await storage.get('accessKey');
+  let phyhubUrl = await storage.get('phyhubUrl');
+  let deviceSerial = await storage.get('deviceSerial');
+  let provisioningCode = await storage.get('provisioningCode');
+  let region = await storage.get('region');
+
+  // migrate credentials if legacy device
+  if (migratedCredentials) {
+    try {
+      logger.info(`connectToPhyHub(): Using migrated credentials `, JSON.stringify(migratedCredentials, null, 2));
+      const {
+        deviceId: migratedDeviceId,
+        deviceSerial: migratedDeviceSerial,
+        accessKey: migratedAccessKey,
+        region: migratedRegion
+      } = migratedCredentials;
+      if (migratedDeviceId) {
+        await storage.set('deviceId', migratedDeviceId);
+        deviceId = migratedDeviceId;
+      }
+      if (migratedDeviceSerial) {
+        await storage.set('deviceSerial', migratedDeviceSerial);
+        deviceSerial = migratedDeviceSerial;
+      }
+      if (migratedAccessKey) {
+        await storage.set('accessKey', migratedAccessKey);
+        accessKey = migratedAccessKey;
+      }
+      if (migratedRegion) {
+        await storage.set('region', migratedRegion);
+        region = migratedRegion;
+        const migratedPhyhubUrl = `https://phyhub.${migratedRegion}.omborigrid.net`;
+        await storage.set('phyhubUrl', migratedPhyhubUrl);
+        phyhubUrl = migratedPhyhubUrl;
+      }
+    } catch (error) {
+      logger.error(`connectToPhyHub(): Unable to migrate credentials:`, error);
+    }
+  }
+
+  // Ensure we have a device serial and it's properly stored
+  if (!deviceSerial) {
+    logger.info('connectToPhyHub(): Getting device identifier');
+    deviceSerial = await getDeviceIdentifier();
+    // Wait for storage to complete before continuing
+    await storage.set('deviceSerial', deviceSerial);
+  }
+
+  // Always store updates to gridEnv, osVersion (for future use)
+  await storage.set('gridEnv', gridEnv);
+  await storage.set('osVersion', osVersion);
+
+  logger.info(`connectToPhyHub(): Connecting device`, {
+    deviceId,
+    accessKey,
+    deviceSerial,
+    gridEnv,
+    provisioningCode,
+    osVersion,
+    phyhubUrl,
+    region,
+  });
+
+  // We are already connected, just return the instance
+  if (phyHubSingleton) {
+    // logger.info(
+    //   `connectToPhyHub(): HubDevice singleton instance found for device ${deviceId}.`
+    // );
+    return { phyHub: phyHubSingleton, deviceSerial };
+  }
+
+  // If we have credentials, do not wait for provisioning code
+  if (deviceId && accessKey && deviceSerial && gridEnv && phyhubUrl) {
+    logger.info(
+      `connectToPhyHub(): Credentials found. Connecting device ${deviceId} to phyhub.`
+    );
+    phyHubSingleton = new HubDevice(
+      phyhubUrl,
+      deviceId,
+      accessKey,
+      deviceSerial,
+      gridEnv,
+      osVersion,
+      region,
+    );
+
+    logger.info(
+      `connectToPhyHub(): Device ${deviceId} connected to phyhub.`
+    );
+    return { phyHub: phyHubSingleton, deviceSerial };
+  }
+
+  const storedDeviceSerial = await storage.get('deviceSerial');
+  // check if deviceSerial is not set, set it.
+  if (!storedDeviceSerial) {
+    await storage.set('deviceSerial', deviceSerial);
+  }
+
+  // logger.info(`connectToPhyHub(): Getting credentials for device ${deviceId}.`);
+  const credentials = await getHubCredentials(phyhubDeviceProvisioningBaseUrls[gridEnv]);
+
+  if (credentials) {
+    const { deviceId, accessKey, phyhubUrl, region } = credentials;
+
+
+    await storage.set('region', region);
+    await storage.set('deviceId', deviceId);
+    await storage.set('accessKey', accessKey);
+    await storage.set('phyhubUrl', phyhubUrl);
+
+    // logger.info(`connectToPhyHub(): Credentials fetched for device ${deviceId}.`);
+    phyHubSingleton = new HubDevice(
+      phyhubUrl,
+      deviceId,
+      accessKey,
+      deviceSerial,
+      gridEnv,
+      osVersion,
+      region
+    );
+    logger.info(
+      `connectToPhyHub(): Device ${deviceId} connected to phyhub.`
+    );
+    return { phyHub: phyHubSingleton, deviceSerial };
+  }
+
+  await getProvisioningCode(phyhubDeviceProvisioningBaseUrls[gridEnv]);
+  const provisioningCodeKey = `provisioningCode_${gridEnv}`;
+  provisioningCode = await storage.get(provisioningCodeKey);
+  logger.info(
+    `connectToPhyHub(): Returning provisioning code ${provisioningCode} for device ${deviceSerial}`
+  );
+  return provisioningCode;
+};
+
+export const getPhyHubInstance = async () => {
+  return phyHubSingleton;
+};
+
+export const getProvisioningInfo = async () => {
+  const storage = await getStorage();
+  const deviceSerial = await storage.get('deviceSerial');
+  let provisioningCode = await storage.get('provisioningCode');
+
+  // If we don't have a provisioning code, try to get a new one
+  if (!provisioningCode) {
+    logger.info('getProvisioningInfo(): No provisioning code found, fetching new one');
+    const gridEnv = await storage.get('gridEnv') || 'PROD';
+    const apiUrl = phyhubDeviceProvisioningBaseUrls[gridEnv];
+
+    const result = await getProvisioningCode(apiUrl);
+    if (result?.provisioningCode) {
+      provisioningCode = result.provisioningCode;
+      logger.info('getProvisioningInfo(): Successfully fetched new provisioning code');
+    } else {
+      logger.error('getProvisioningInfo(): Failed to fetch provisioning code');
+    }
+  }
+
+  return {
+    provisioningCode,
+    deviceSerial,
+  };
+};
+
+export class HubDevice {
+  public gridEnv: string;
+  public osVersion: string;
+  public phyhubUrl: string | null = null;
+  public deviceId: string | null = null;
+  public accessKey: string | null = null;
+  public deviceSerial: string | null = null;
+  public region: string | null = null;
+
+  public socket: Socket | null = null;
+  private socketConnected: boolean = false;
+  private socketAuthenticated: boolean = false;
+  private onTwinUpdate: ((twins: TwinResponse) => void) | null = null;
+  private onTwinRemove: ((twins: TwinResponse) => void) | null = null;
+  private emitQueue: any[] = [];
+  private emitAuthQueue: any[] = [];
+  private scheduler: any | null = null;
+  private deletedTwins: string[] = [];
+
+  private intervals: any = {};
+  private peripheralTwinMutex = new Mutex();
+  private eventCallbacks: Map<string, Array<(data: any) => void>> = new Map();
+  private reconnectListeners: Array<() => void> = [];
+  private authReconnectListeners: Array<() => void> = [];
+
+  constructor(
+    phyhubUrl: string,
+    deviceId: string,
+    accessKey: string,
+    deviceSerial: string,
+    gridEnv: string = 'PROD',
+    osVersion: string = 'N/A',
+    region: string,
+  ) {
+    this.phyhubUrl = phyhubUrl;
+    this.deviceId = deviceId;
+    this.accessKey = accessKey;
+    this.deviceSerial = deviceSerial;
+    this.gridEnv = gridEnv.toUpperCase();
+    this.osVersion = osVersion;
+    this.region = region.toUpperCase();
+  }
+
+  public setTwinUpdateHandler(callback: (twins: TwinResponse) => void) {
+    this.onTwinUpdate = callback;
+    // logger.info('setTwinUpdateHandler(): Twin update handler set');
+  }
+
+  public setTwinRemoveHandler(callback: (twins: TwinResponse) => void) {
+    this.onTwinRemove = callback;
+    // logger.info('setTwinRemoveHandler(): Twin remove handler set');
+  }
+
+  public isConnected() {
+    return this.socketConnected;
+  }
+
+  public isAuthenticated() {
+    return this.socketAuthenticated;
+  }
+
+  public async connect() {
+    try {
+      const { deviceId, accessKey, gridEnv, osVersion, phyhubUrl } = this;
+      if (!deviceId || !accessKey) {
+        logger.error('connect(): DeviceId or AccessKey not set');
+        return;
+      }
+
+
+      if (!phyhubUrl) {
+        logger.error('connect(): Phyhub URL not set');
+        return;
+      }
+
+      logger.info(`connect(): Connecting device `, { deviceId, accessKey, gridEnv, osVersion });
+      this.socket = await this.connectSocket(deviceId, accessKey, phyhubUrl);
+    } catch (error) {
+      logger.error(`connect(): Failed to connect socket`, error);
+    }
+
+    return this;
+  }
+
+  public on(event: string, callback: (data: any) => void) {
+    const { socket, deviceId } = this;
+    // logger.info('SOCKET on(): Registering event handler', { event, deviceId });
+
+    if (!this.eventCallbacks.has(event)) {
+      this.eventCallbacks.set(event, []);
+    }
+    this.eventCallbacks.get(event)!.push(callback);
+
+    if (!socket || !deviceId) {
+      logger.error('SOCKET on(): No socket or deviceId available', { socket: !!socket, deviceId });
+      return callback({ error: `connectDevice ${deviceId}: Not connected` });
+    }
+
+    socket.on(event, (data: any) => {
+      if (this.isConnected()) {
+        // logger.info(`SOCKET on(): Received ${event} event`, { deviceId, data });
+        this.eventCallbacks.get(event)!.forEach(cb => cb(data));
+      } else {
+        logger.warn(`SOCKET on(): Ignoring ${event} event as socket is not connected`, { deviceId });
+      }
+    });
+
+    logger.info('SOCKET on(): Successfully registered callback for event', { event, deviceId });
+  }
+
+  public emit(...args: any) {
+    const { socket, emitQueue } = this;
+
+    if (!socket) {
+      logger.error('emit(): Socket not created');
+      return;
+    }
+    if (!this.isConnected()) {
+      logger.info('SOCKET emit(): Pushing to emitQueue');
+      emitQueue.push(args);
+      return;
+    }
+    socket.emit.apply(socket, args);
+  }
+
+  public emitAuth(...args: any) {
+    const { socket, emitAuthQueue } = this;
+    if (!socket) {
+      logger.error('emitAuth(): Socket not created');
+      return;
+    }
+    if (!this.isConnected() || !this.isAuthenticated()) {
+      // logger.info('SOCKET emitAuth(): Pushing to emitAuthQueue');
+      emitAuthQueue.push(args);
+      return;
+    }
+
+    // const [event, payload, ...rest] = args;
+    // if (event === 'getPeripheralTwins') {
+    //   this.getPeripheralTwins(payload);
+    //   return;
+    // }
+    socket.emit.apply(socket, args);
+  }
+
+  private processEmitQueue() {
+    logger.info('SOCKET processEmitQueue(): processing emit queue');
+    const { socket, emitQueue } = this;
+
+    if (!socket || !this.isConnected()) {
+      logger.info('SOCKET processEmitQueue(): Aborting', {
+        socket: !!socket,
+        socketConnected: this.isConnected(),
+      });
+      return;
+    }
+
+    while (emitQueue.length > 0) {
+      const args = emitQueue.shift();
+      socket.emit.apply(socket, args);
+    }
+    this.processEmitAuthQueue();
+  }
+
+  private processEmitAuthQueue() {
+    logger.info('SOCKET processEmitAuthQueue(): processing emit auth queue');
+    const { socket, emitAuthQueue } = this;
+
+    if (!socket || !this.isConnected() || !this.isAuthenticated()) {
+      logger.info('SOCKET processEmitAuthQueue(): Aborting', {
+        socket: !!socket,
+        socketConnected: this.isConnected(),
+        socketAuthenticated: this.isAuthenticated(),
+      });
+      return;
+    }
+
+    while (emitAuthQueue.length > 0) {
+      const args = emitAuthQueue.shift();
+      socket.emit.apply(socket, args);
+    }
+  }
+
+  private executeReconnectListeners() {
+    this.reconnectListeners.forEach(listener => {
+      try {
+        listener();
+      } catch (error) {
+        logger.error('Error executing reconnect listener:', error);
+      }
+    });
+  }
+
+  private executeAuthReconnectListeners() {
+    this.authReconnectListeners.forEach(listener => {
+      try {
+        listener();
+      } catch (error) {
+        logger.error('Error executing reconnect listener:', error);
+      }
+    });
+  }
+
+  private async connectSocket(
+    deviceId: string,
+    accessKey: string,
+    phyhubUrl: string
+  ): Promise<Socket | null> {
+    // logger.info('SOCKET connectSocket(): Creating new socket', { deviceId, accessKey, phyhubUrl });
+
+    // Updated to use getSocketIOWithProxy
+    const socket: Socket = await getSocketIOWithProxy(phyhubUrl, {
+      auth: { deviceId, accessKey },
+      reconnection: true,
+      reconnectionDelayMax: 1000,
+      reconnectionAttempts: Infinity,
+    });
+
+    socket.on('connect', () => {
+      logger.info(
+        `SOCKET connectSocket() on connect: Connected to phyhub ${phyhubUrl}  🟢-🟢-🟢-🟢-⚪`
+      );
+      this.socketConnected = true;
+      this.processEmitQueue();
+      if (this.socketConnected) {
+        this.executeReconnectListeners();
+      }
+      // If we're already authenticated, call reconnect listeners and process auth queue
+      if (this.socketAuthenticated) {
+        logger.info('SOCKET connectSocket() on reconnect: Socket already authenticated, notifying listeners');
+        this.executeAuthReconnectListeners();
+        this.processEmitAuthQueue();
+      }
+    });
+
+    socket.on('disconnect', () => {
+      logger.info('SOCKET connectSocket() on disconnect: Disconnected from server');
+      this.socketConnected = false;
+    });
+
+    socket.on('deviceAuthenticated', (response: any) => {
+      logger.info('SOCKET connectSocket() on deviceAuthenticated: Device authenticated', response);
+      this.socketAuthenticated = true;
+      if (response.status === 'success') {
+        // Execute reconnect listeners when device is authenticated
+        this.executeReconnectListeners();
+        this.processEmitAuthQueue();
+      } else {
+        logger.error('SOCKET connectSocket() on deviceAuthenticated: Device authentication failed', response);
+      }
+    });
+
+    socket.io.on('reconnect', (attempt: number) => {
+      logger.info(`SOCKET connectSocket() on reconnect: Reconnected to server attempt: ${attempt}`);
+      this.socketConnected = true;
+      this.processEmitQueue();
+    });
+
+    socket.on('twinUpdated', async (payload: EventPayload<TwinResponse>) => {
+      logger.info('SOCKET connectSocket() on twinUpdated: syncing twin on device');
+      if (!payload.data) return;
+
+      const twin = payload.data;
+      await this.cacheTwins([twin]);
+
+      if (this.onTwinUpdate) {
+        this.onTwinUpdate(twin);
+      }
+    });
+
+    socket.on('twinCreated', async (payload: EventPayload<TwinResponse>) => {
+      logger.info('SOCKET connectSocket() on twinCreated: Adding new twin to device');
+      if (payload.data) {
+        await this.cacheTwins([payload.data]);
+        if (this.onTwinUpdate) {
+          this.onTwinUpdate(payload.data);
+        }
+      }
+    });
+
+    socket.on('twinDeleted', async (payload: EventPayload<TwinResponse>) => {
+      logger.info('SOCKET connectSocket() on twinDeleted: Removing twin from device');
+      if (this.onTwinRemove && payload.data) {
+        await this.removeCachedTwin([payload.data]);
+        this.onTwinRemove(payload.data);
+      }
+    });
+
+    // socket.on('twinMessage', async (payload: EventPayload) => {
+    //   logger.info('SOCKET connectSocket() on twinMessage: received twin message', JSON.stringify(payload, null, 2));
+    // });
+
+    socket.io.on('reconnect_attempt', (attempt: number) => {
+      logger.info(`SOCKET connectSocket() on reconnect_attempt: Reconnect attempt: ${attempt}`);
+    });
+
+    socket.io.on('reconnect_error', (error: Error) => {
+      logger.info('SOCKET connectSocket() on reconnect_error: ', error);
+    });
+
+    socket.io.on('reconnect_failed', () => {
+      logger.info('SOCKET connectSocket() on reconnect_failed: Reconnect failed');
+    });
+
+    return socket;
+  }
+
+  public getDeviceStatus = async (): Promise<DeviceStatus> => {
+    const storage = await getStorage();
+    const deviceId = await storage.get('deviceId');
+    const accessKey = await storage.get('accessKey');
+    const deviceSerial = await storage.get('deviceSerial');
+    const provisioningCode = accessKey ? 'N/A' : await storage.get('provisioningCode');
+    const gridEnv = await storage.get('gridEnv');
+    const osVersion = await storage.get('osVersion');
+    const dataResidency = await storage.get('region');
+    const twins = await this.getCachedTwins();
+
+    let displayName = '';
+    let deviceEnv= '';
+    let spaceId = '';
+    let tenantId = '';
+    let ip: DeviceIp[] = [];
+
+    const cachedTwins = await this.getCachedTwins();
+    try {
+      const deviceTwinInstanceId = cachedTwins?.[TwinTypeEnum.Device]?.[0];
+      if (deviceTwinInstanceId) {
+        const deviceTwinInstance: DeviceTwinResponse = await this.getCachedTwins(deviceTwinInstanceId);
+        if (deviceTwinInstance) {
+          displayName = deviceTwinInstance.properties.desired.displayName;
+          deviceEnv = deviceTwinInstance.properties.desired.env;
+          spaceId = deviceTwinInstance.properties.desired.spaceId;
+          tenantId = deviceTwinInstance.tenantId;
+          ip = deviceTwinInstance.properties.reported.ip
+        }
+      }
+    } catch (error) {
+      logger.error(`Device twin not found for device ${deviceId}`, error);
+    }
+
+    const response = {
+      deviceId,
+      accessKey,
+      deviceSerial,
+      gridEnv,
+      osVersion,
+      provisioningCode,
+      displayName,
+      deviceEnv,
+      spaceId,
+      tenantId,
+      dataResidency,
+      ip,
+      socketConnected: this.isConnected(),
+      socketAuthenticated: this.isAuthenticated(),
+      twins,
+    };
+    return response;
+  };
+
+  public getDeviceInstance = async () => {
+    const storage = await getStorage();
+    const deviceId = await storage.get('deviceId');
+    const twins = await this.getCachedTwins();
+
+    try {
+      const deviceTwinInstanceId = twins[TwinTypeEnum.Device][0];
+      if (deviceTwinInstanceId) {
+        const deviceTwinInstance = await this.getCachedTwins(deviceTwinInstanceId);
+        if (deviceTwinInstance) {
+          return { twin: deviceTwinInstance };
+        }
+      }
+      return {};
+    } catch (error) {
+      logger.error(`Device twin not found for device ${deviceId}`, error);
+      return {};
+    }
+  };
+
+  public getDeviceNetworks = async () => {
+    try {
+      const sysinfo = await getSysinfo();
+      const { networkInterfaces, wifiInterfaces, wifiNetworks, wifiConnections } = sysinfo;
+      return {
+        networkInterfaces,
+        wifiInterfaces,
+        wifiNetworks,
+        wifiConnections,
+      };
+    } catch (error) {
+      logger.error(`Unable to get network information of the device`, error);
+      return {
+        wifiNetworks: [],
+        wifiConnections: [],
+        networkInterfaces: [],
+        wifiInterfaces: [],
+      };
+    }
+  };
+
+  public getScreenInstance = async () => {
+    const storage = await getStorage();
+    const deviceId = await storage.get('deviceId');
+
+    try {
+      const twins = await this.getCachedTwins();
+      console.log('getScreenInstance(): twins', JSON.stringify(twins, null, 2));
+      if(!twins[TwinTypeEnum.Screen]) {
+        return {};
+      }
+      const screenTwinInstanceId = twins[TwinTypeEnum.Screen][0];
+
+      if (screenTwinInstanceId) {
+        const screenTwinInstance = await this.getCachedTwins(screenTwinInstanceId);
+        if (screenTwinInstance) {
+          return { twin: screenTwinInstance };
+        }
+      }
+      return {};
+    } catch (error) {
+      logger.error(`Screen instance not found for device ${deviceId}`, error);
+      return {};
+    }
+  };
+
+  public async connectDevice(callback: (data: any) => void) {
+    const { socket, deviceId } = this;
+    logger.info(`connectDevice(): Connecting device ${deviceId}`);
+
+    if (!socket || !deviceId) {
+      return callback({ error: `connectDevice ${deviceId}: Not connected` });
+    }
+
+    let deviceTwin: any = undefined;
+    let cachedTwinsInfo: Record<string, string[]> | undefined;
+    let shouldUseCachedResponse = false;
+
+    try {
+      cachedTwinsInfo = await this.getCachedTwins();
+      if (cachedTwinsInfo && cachedTwinsInfo[TwinTypeEnum.Device] && cachedTwinsInfo[TwinTypeEnum.Device].length > 0) {
+        const deviceTwinId = cachedTwinsInfo[TwinTypeEnum.Device][0];
+        deviceTwin = await this.getCachedTwins(deviceTwinId);
+        // Only use cached response if device twin exists and has valid properties
+        shouldUseCachedResponse = deviceTwin && deviceTwin.properties && deviceTwin.properties.desired;
+      }
+    } catch (error) {
+      logger.info(`connectDevice(): No cached twins found, will fetch fresh twins`);
+    }
+
+    const reportSystemInformation = async () => {
+      logger.info('reportSystemInformation(): About to fetch system information');
+      const deviceInfo = await getSysinfo();
+      let ips: Array<{interface: string; ipv4: string; ipv6: string}> = [];
+
+      try {
+        const { networkInterfaces } = deviceInfo;
+        for (const iface of networkInterfaces) {
+          if (iface.ip4 && iface.ip4 !== '127.0.0.1') { // Skip loopback address
+            ips.push({
+              interface: iface.ifaceName,
+              ipv4: iface.ip4,
+              ipv6: iface.ip6,
+            });
+          }
+        }
+      } catch (error) {
+        logger.error('Failed to detect IP address of device', error);
+      }
+
+      // If we're in the browser, pick the osVersion from the last path segment.
+      // Otherwise (Node environment), fallback to whatever was stored.
+      const storage = await getStorage();
+      const isBrowser = typeof window !== 'undefined';
+
+      let finalOsVersion;
+      if (isTizen) {
+        finalOsVersion = deviceInfo?.os?.osVersion || '';
+      } else if (isBrowser && window.location && window.location.pathname) {
+        const segments = window.location.pathname.split('/').filter(Boolean);
+        finalOsVersion = segments.length ? segments[segments.length - 1] : 'N/A';
+      } else {
+        finalOsVersion = (await storage.get('osVersion')) || 'N/A';
+      }
+
+      const gridEnv = await storage.get('gridEnv');
+
+      const deviceTwinReportedProperties: EventPayload<DeviceTwinReportedProperties> = {
+        data: {
+          ...deviceInfo,
+          ip: deviceInfo?.ip && deviceInfo?.ip?.length > 0 ? deviceInfo.ip : ips,
+          os: {
+            osVersion: finalOsVersion,
+          },
+          env: {
+            gridEnv,
+          },
+          phydeviceVersion: getVersion(),
+        },
+      };
+
+      logger.info('reportSystemInformation(): About to emit system information');
+      socket.emit(
+        'reportDeviceTwinProperties',
+        deviceTwinReportedProperties,
+        async (_response: any) => {
+          logger.info('reportSystemInformation(): Emitted system information');
+        }
+      );
+    };
+
+    // Immediately send system information upon a new socket connection
+    reportSystemInformation();
+
+    if (!this.intervals['reportSystemInformation']) {
+      // Changed the interval from 60000 (1 minute) to 300000 (5 minutes)
+      this.intervals['reportSystemInformation'] = setInterval(async () => {
+        // Only emit if connected and authenticated
+        if (!this.isConnected() || !this.isAuthenticated()) {
+          return;
+        }
+        reportSystemInformation();
+      }, 300000);
+    }
+
+    const connector = async () => {
+      this.emitAuth('connectDevice', async (response: any) => {
+        console.log('connector connectDevice(): response', response);
+
+        // If server response is valid, use server response
+        if (response.status === 'success' && response.twins) {
+          callback(response);
+          const { twins }: { twins: TwinResponse[] } = response;
+          logger.info(
+            `SOCKET connector(): received ${twins.length} twins in response.   🟢-🟢-🟢-🟢-🟢`
+          );
+          await this.cacheTwins(twins);
+        } else if (shouldUseCachedResponse && deviceTwin && cachedTwinsInfo) {
+          // Fallback to cached response if server fails
+          const storage = await getStorage();
+          const region = await storage.get('region');
+          const phyhubUrl = await storage.get('phyhubUrl');
+          const transformedTwins = await this.transformCachedTwinsToArray(cachedTwinsInfo);
+          logger.info('connectDevice(): Using cached twins as fallback due to server error');
+          callback({ status: 'success', twins: transformedTwins, region, phyhubUrl });
+        } else {
+          // No cached twins available and server failed
+          logger.error(
+            `SOCKET connector(): No twins received in response and no cached fallback available.   🟢-🟢-🟢-🟢-🔴`
+          );
+          callback(response);
+        }
+      });
+    };
+    connector();
+    socket.on('reconnect', connector);
+  }
+
+  // Add new helper method to transform cached twins format
+  private async transformCachedTwinsToArray(cachedTwins: Record<string, string[]>): Promise<TwinResponse[]> {
+    const transformedTwins: TwinResponse[] = [];
+
+    for (const [_type, twinIds] of Object.entries(cachedTwins)) {
+      for (const twinId of twinIds) {
+        const twin = await this.getCachedTwins(twinId);
+        if (twin) {
+          transformedTwins.push(twin);
+        }
+      }
+    }
+
+    return transformedTwins;
+  }
+
+  private cacheTwins = async (twins: TwinResponse[]) => {
+    // logger.info(`cacheTwins(): Caching twins`);
+
+    for (const twin of twins) {
+        try {
+          // Handle peripheral twin separately
+          if (twin.type === TwinTypeEnum.Peripheral) {
+            await this.cachePeripheralTwins(twin);
+            continue;
+          }
+
+          // Existing job scheduling logic
+          const { type, id } = twin;
+          if (type === TwinTypeEnum.Device) {
+            const reported = twin.properties?.reported as DeviceTwinReportedProperties | undefined;
+            const jobs = reported?.jobs ?? [];
+            if (jobs.length > 0 && this.scheduler) {
+              this.scheduler.processJobs(jobs, twin?.properties?.desired?.timezone ?? 'UTC', id);
+            }
+          }
+        } catch (error) {
+          logger.error(`cacheTwins(): Failed to schedule job for device twin ${twin.id}`, error);
+        }
+    }
+
+    const storage = await getStorage();
+    const twinsInfo: Record<string, string[]> = {};
+    let twinsInfoCachePath = ``;
+    for (const twin of twins) {
+      if (twin && !this.deletedTwins.includes(twin.id)) {
+        const { type, deviceId, id } = twin;
+        twinsInfoCachePath = `twins-device-${deviceId}`;
+
+        const twinCachePath = `${id}-device-${deviceId}`;
+        // logger.info(`cacheTwins(): Caching ${type} twin ${id}`);
+        await storage.set(twinCachePath, twin);
+
+        if (!twinsInfo[type]) {
+          twinsInfo[type] = [];
+        }
+        twinsInfo[type].push(id);
+      }
+    }
+
+    let cachedTwinsInfo = undefined;
+    try {
+      cachedTwinsInfo = await storage.get(twinsInfoCachePath);
+    } catch (error) {
+      // logger.info(`cacheTwins(): ${twinsInfoCachePath} not found, creating cache`);
+    }
+
+    if (cachedTwinsInfo) {
+      // merge cached twins info with fresh twins info
+      const updatedTwinsInfo = { ...cachedTwinsInfo };
+      for (const key in twinsInfo) {
+        if (Object.prototype.hasOwnProperty.call(updatedTwinsInfo, key)) {
+          updatedTwinsInfo[key] = Array.from(
+            new Set([...updatedTwinsInfo[key], ...twinsInfo[key]])
+          );
+        } else {
+          updatedTwinsInfo[key] = twinsInfo[key];
+        }
+      }
+
+      // logger.info(`cacheTwins(): Updating twins info cache`);
+      await storage.set(twinsInfoCachePath, updatedTwinsInfo);
+    } else {
+      // logger.info(`cacheTwins(): Updating twins info cache`);
+      await storage.set(twinsInfoCachePath, twinsInfo);
+    }
+  };
+
+  private async removeCachedTwin(twins: TwinResponse[] | TwinResponse | string) {
+    const storage = await getStorage();
+    const twinsArray = Array.isArray(twins) ? twins : [twins];
+
+    for (const twin of twinsArray) {
+      const twinData = typeof twin === 'string'
+      ? await this.getCachedTwins(twin)
+      : twin;
+
+      if (!twinData) continue;
+
+      const { type, deviceId, id, instanceId } = twinData;
+
+      // Handle peripheral twins differently
+      if (type === TwinTypeEnum.Peripheral && instanceId) {
+        await this.peripheralTwinMutex.runExclusive(async () => {
+          const cachePath = `peripheral-twins-${instanceId}`;
+          const peripheralTwins = await storage.get(cachePath) || {};
+          delete peripheralTwins[id];
+          await storage.set(cachePath, peripheralTwins);
+        });
+        continue;
+      }
+
+      // Existing logic for other twin types
+      const twinCachePath = `${id}-device-${deviceId}`;
+      const twinsInfoCachePath = `twins-device-${deviceId}`;
+      try {
+        // Remove individual twin cache
+        logger.info(`removeCachedTwin(): Removing ${type} twin ${id}`);
+        await storage.remove(twinCachePath);
+
+        // Update twins info cache
+        const cachedTwinsInfo = await storage.get(twinsInfoCachePath);
+        if (cachedTwinsInfo && cachedTwinsInfo[type]) {
+          cachedTwinsInfo[type] = cachedTwinsInfo[type].filter(
+            (cachedId: string) => cachedId !== id
+          );
+
+          if (cachedTwinsInfo[type].length === 0) {
+            delete cachedTwinsInfo[type];
+          }
+
+          if (Object.keys(cachedTwinsInfo).length > 0) {
+            await storage.set(twinsInfoCachePath, cachedTwinsInfo);
+          } else {
+            await storage.remove(twinsInfoCachePath);
+          }
+        }
+        this.deletedTwins.push(id);
+      } catch (error) {
+        logger.info(`removeCachedTwin(): No twins info cache found for ${twinsInfoCachePath}`);
+      }
+    }
+  }
+
+  public getCachedTwins = async (twinId: string | undefined = undefined) => {
+    const storage = await getStorage();
+    if (twinId) {
+      const twinCachePath = `${twinId}-device-${this.deviceId}`;
+      const cachedTwin = await storage.get(twinCachePath);
+      return cachedTwin;
+    } else {
+      const twinsInfoCachePath = `twins-device-${this.deviceId}`;
+      const cachedTwinsInfo = await storage.get(twinsInfoCachePath) || {};
+      return cachedTwinsInfo;
+    }
+  };
+
+  public async reportScreenInstanceProperties(
+    properties: EventPayload<ScreenTwinReportedProperties>,
+    callback: (data: any) => void
+  ) {
+    const { socket, deviceId } = this;
+    if (!socket || !deviceId) {
+      return callback({ error: `reportScreenInstanceProperties() ${deviceId}: Not connected` });
+    }
+
+    this.emitAuth('reportScreenTwinProperties', properties, async (response: any) => {
+      if (response.status === PhyHubResponseStatus.success) {
+        // logger.info(
+        //   `reportScreenInstanceProperties() on reportScreenProperties: device ${deviceId} screen app properties reported`
+        // );
+        const { twin } = response;
+        if (!twin) {
+          logger.info(
+            `reportScreenInstanceProperties() on reportScreenProperties: failed to cache screen twin updates for device ${deviceId}`
+          );
+        } else {
+          await this.cacheTwins([twin]);
+        }
+      } else {
+        logger.info(
+          `reportScreenInstanceProperties() on reportScreenProperties: failed to report screen app properties of device ${deviceId}`
+        );
+      }
+      callback(response);
+    });
+  }
+
+  public async getEdgeInstance(
+    payload: EventPayload
+  ) {
+    const storage = await getStorage();
+    const deviceId = await storage.get('deviceId');
+
+    try {
+      const { twinId } = payload;
+      const twins = await this.getCachedTwins();
+      const edgeTwin = twins[TwinTypeEnum.Edge].filter((id: string) => id === twinId);
+
+      if (edgeTwin && edgeTwin.length > 0) {
+        const edgeTwinInstance = await this.getCachedTwins(edgeTwin[0]);
+        if (edgeTwinInstance) {
+          return { twin: edgeTwinInstance };
+        }
+      }
+      return {};
+    } catch (error) {
+      logger.error(`Edge instance not found for device ${deviceId}`, error);
+      return {};
+    }
+  }
+
+  public async sendEventSignal(
+    payload: EventPayload<Record<string, any>>
+  ) {
+    logger.info(`sendEventSignal(): sending Event Signal from device ${this.deviceId}`, payload);
+    const { socket, deviceId } = this;
+    if (!socket || !deviceId) {
+      logger.error(`sendEventSignal(): Device or socket not connected`);
+      return;
+    }
+
+    this.emitAuth('signalEvent', payload);
+  }
+
+  public async sendClientSignal(
+    payload: EventPayload<Record<string, any>>
+  ) {
+    logger.info(`sendClientSignal(): sending Client Signal from device ${this.deviceId}`, payload);
+    const { socket, deviceId } = this;
+    if (!socket || !deviceId) {
+      logger.error(`sendClientSignal(): Device or socket not connected`);
+      return;
+    }
+
+    this.emitAuth('signalClient', payload);
+  }
+
+  public async sendSessionSignal(
+    payload: EventPayload<Record<string, any>>
+  ) {
+    logger.info(`sendSessionSignal(): sending Session Signal from device ${this.deviceId}`, payload);
+    const { socket, deviceId } = this;
+    if (!socket || !deviceId) {
+      logger.error(`sendSessionSignal(): Device or socket not connected`);
+      return;
+    }
+
+    this.emitAuth('signalSession', payload);
+  }
+
+  public async reportEdgeTwinProperties(
+    instanceTwinId: string,
+    properties: EdgeTwinReportedProperties,
+    callback: (data: any) => void
+  ) {
+    logger.info(`reportEdgeTwinProperties(): Reporting twin ${instanceTwinId} properties`);
+    const { socket, deviceId } = this;
+    if (!socket || !deviceId) {
+      return callback({ error: `reportEdgeTwinProperties(): Device or socket not connected` });
+    }
+
+    const payload: EventPayload = {
+      twinId: instanceTwinId,
+      data: properties,
+    };
+
+    this.emitAuth('reportEdgeTwinProperties', payload, async (response: any) => {
+      const { twin } = response;
+      if (twin) {
+        await this.cacheTwins([twin]);
+      }
+    });
+  }
+
+  public async reportDeviceTwinProperties(
+    instanceTwinId: string,
+    properties: DeviceTwinReportedProperties,
+    callback: (data: any) => void
+  ) {
+    // logger.info(`reportDeviceTwinProperties(): Reporting device twin ${instanceTwinId} properties`);
+    const { socket, deviceId } = this;
+    if (!socket || !deviceId) {
+      return callback({ error: `reportDeviceTwinProperties(): Device or socket not connected` });
+    }
+
+    const payload: EventPayload<DeviceTwinReportedProperties> = {
+      twinId: instanceTwinId,
+      data: properties,
+    };
+
+    this.emitAuth('reportDeviceTwinProperties', payload, async (response: any) => {
+      const { twin } = response;
+      if (twin) {
+        await this.cacheTwins([twin]);
+      }
+    });
+  }
+
+  public async reportDeviceJob(instanceTwinId: string, job: Job, callback: (data: any) => void) {
+    // logger.info(`reportDeviceJob(): Reporting device twin ${instanceTwinId} job ${job.id}`);
+    const { socket, deviceId } = this;
+    if (!socket || !deviceId) {
+      return callback({ error: `reportDeviceJob(): Device or socket not connected` });
+    }
+
+    const payload: EventPayload<Job> = {
+      twinId: instanceTwinId,
+      data: job,
+    };
+
+    this.emitAuth('reportDeviceJob', payload, async (response: any) => {
+      const { twin } = response;
+      if (twin) {
+        await this.cacheTwins([twin]);
+      }
+    });
+  }
+
+  public async reportPeripheralTwinProperties(
+    instanceTwinId: string,
+    properties: PeripheralTwinReportedProperties,
+    callback?: (data: any) => void
+  ) {
+    // logger.info(`reportPeripheralTwinProperties(): Reporting twin ${instanceTwinId} properties`);
+    const { socket, deviceId } = this;
+    if (!socket || !deviceId) {
+      return callback?.({ error: `reportPeripheralTwinProperties(): Device or socket not connected` });
+    }
+
+    const payload: EventPayload = {
+      twinId: instanceTwinId,
+      data: properties,
+    };
+
+    this.emitAuth('reportPeripheralTwinProperties', payload, async (response: any) => {
+      const { twin } = response;
+      if (twin) {
+        await this.cacheTwins([twin]);
+      }
+      callback?.(response);
+    });
+  }
+
+  public setScheduler(scheduler: any) {
+    this.scheduler = scheduler;
+    if (scheduler && typeof scheduler.setHubDevice === 'function') {
+      scheduler.setHubDevice(this);
+    }
+    logger.info('setScheduler(): Scheduler has been set');
+  }
+
+  private async cachePeripheralTwins(twin: TwinResponse) {
+    if (twin.type !== TwinTypeEnum.Peripheral || !twin.instanceId) return;
+
+    return await this.peripheralTwinMutex.runExclusive(async () => {
+      const storage = await getStorage();
+      const cachePath = `peripheral-twins-${twin.instanceId}`;
+      let peripheralTwins = await storage.get(cachePath) || {};
+
+      peripheralTwins[twin.id] = twin;
+      await storage.set(cachePath, peripheralTwins);
+      return peripheralTwins;
+    });
+  }
+
+  public async getPeripheralTwins(payload: EventPayload<{ instanceId: string }>) {
+    const { data } = payload;
+    // console.log('getPeripheralTwins(): payload', payload);
+    if (!data?.instanceId) {
+      logger.error('getPeripheralTwins(): Missing instanceId in payload');
+      return { peripheralTwins: {} };
+    }
+    return await this.peripheralTwinMutex.runExclusive(async () => {
+      // Get current cached twins
+      const storage = await getStorage();
+      const cachePath = `peripheral-twins-${data.instanceId}`;
+      const cachedTwins = await storage.get(cachePath) || {};
+
+      try {
+        // Get fresh twins from server
+        const response = await new Promise<{ peripheralTwins: Record<string, TwinResponse> }>((resolve, reject) => {
+          this.emitAuth('getPeripheralTwins', payload, resolve);
+          this.socket?.on('error', reject);
+        });
+
+        // Ensure peripheralTwins exists and is an object
+        const peripheralTwins = response?.peripheralTwins || {};
+
+        // Cache new twins using cachePeripheralTwins
+        for (const twin of Object.values(peripheralTwins)) {
+          await this.cachePeripheralTwins(twin);
+        }
+
+        // Find and remove deleted twins
+        const cachedTwinIds = Object.keys(cachedTwins);
+        const currentTwinIds = Object.keys(peripheralTwins);
+        const deletedTwinIds = cachedTwinIds.filter(id => !currentTwinIds.includes(id));
+
+        if (deletedTwinIds.length > 0) {
+          await this.removeCachedTwin(deletedTwinIds.map(id => cachedTwins[id]));
+        }
+
+        return { peripheralTwins };
+      } catch (error) {
+        logger.error('getPeripheralTwins(): Error during execution', error);
+        return { peripheralTwins: {} };
+      }
+    });
+  }
+
+  public onReconnect(listener: () => void) {
+    this.reconnectListeners.push(listener);
+    // logger.info('onReconnect(): Added new reconnect listener');
+  }
+
+  public onAuthReconnect(listener: () => void) {
+    this.authReconnectListeners.push(listener);
+    // logger.info('onAuthReconnect(): Added new auth reconnect listener');
+  }
+}
+
+
+
+export default {
+  connectToPhyHub,
+  getPhyHubInstance,
+  getProvisioningInfo,
+};