@phystack/hub-device 4.3.40-dev

package/dist/index.js

@@ -0,0 +1,967 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HubDevice = exports.getProvisioningInfo = exports.getPhyHubInstance = exports.connectToPhyHub = void 0;
+const socket_io_proxy_1 = require("@phystack/socket.io-proxy");
+const storage_1 = __importDefault(require("./storage"));
+const sysinfo_1 = __importStar(require("./sysinfo"));
+const get_device_identifier_utility_1 = __importDefault(require("./utilities/get-device-identifier.utility"));
+const get_hub_credentials_utility_1 = __importDefault(require("./utilities/get-hub-credentials.utility"));
+const get_provisioning_code_utility_1 = __importDefault(require("./utilities/get-provisioning-code.utility"));
+const twin_types_1 = require("./types/twin.types");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const async_mutex_1 = require("async-mutex");
+var PhyHubResponseStatus;
+(function (PhyHubResponseStatus) {
+    PhyHubResponseStatus["success"] = "success";
+    PhyHubResponseStatus["error"] = "error";
+})(PhyHubResponseStatus || (PhyHubResponseStatus = {}));
+const logger = console;
+function getVersion() {
+    const pkgPath = path_1.default.resolve(__dirname, '../package.json');
+    try {
+        const content = fs_1.default.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 = {
+    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 = null;
+const connectToPhyHub = async (gridEnv = 'PROD', osVersion = 'N/A', migratedCredentials = undefined) => {
+    const storage = await (0, storage_1.default)();
+    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');
+    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);
+        }
+    }
+    if (!deviceSerial) {
+        logger.info('connectToPhyHub(): Getting device identifier');
+        deviceSerial = await (0, get_device_identifier_utility_1.default)();
+        await storage.set('deviceSerial', deviceSerial);
+    }
+    await storage.set('gridEnv', gridEnv);
+    await storage.set('osVersion', osVersion);
+    logger.info(`connectToPhyHub(): Connecting device`, {
+        deviceId,
+        accessKey,
+        deviceSerial,
+        gridEnv,
+        provisioningCode,
+        osVersion,
+        phyhubUrl,
+        region,
+    });
+    if (phyHubSingleton) {
+        return { phyHub: phyHubSingleton, deviceSerial };
+    }
+    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');
+    if (!storedDeviceSerial) {
+        await storage.set('deviceSerial', deviceSerial);
+    }
+    const credentials = await (0, get_hub_credentials_utility_1.default)(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);
+        phyHubSingleton = new HubDevice(phyhubUrl, deviceId, accessKey, deviceSerial, gridEnv, osVersion, region);
+        logger.info(`connectToPhyHub(): Device ${deviceId} connected to phyhub.`);
+        return { phyHub: phyHubSingleton, deviceSerial };
+    }
+    await (0, get_provisioning_code_utility_1.default)(phyhubDeviceProvisioningBaseUrls[gridEnv]);
+    const provisioningCodeKey = `provisioningCode_${gridEnv}`;
+    provisioningCode = await storage.get(provisioningCodeKey);
+    logger.info(`connectToPhyHub(): Returning provisioning code ${provisioningCode} for device ${deviceSerial}`);
+    return provisioningCode;
+};
+exports.connectToPhyHub = connectToPhyHub;
+const getPhyHubInstance = async () => {
+    return phyHubSingleton;
+};
+exports.getPhyHubInstance = getPhyHubInstance;
+const getProvisioningInfo = async () => {
+    const storage = await (0, storage_1.default)();
+    const deviceSerial = await storage.get('deviceSerial');
+    let provisioningCode = await storage.get('provisioningCode');
+    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 (0, get_provisioning_code_utility_1.default)(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,
+    };
+};
+exports.getProvisioningInfo = getProvisioningInfo;
+class HubDevice {
+    gridEnv;
+    osVersion;
+    phyhubUrl = null;
+    deviceId = null;
+    accessKey = null;
+    deviceSerial = null;
+    region = null;
+    socket = null;
+    socketConnected = false;
+    socketAuthenticated = false;
+    onTwinUpdate = null;
+    onTwinRemove = null;
+    emitQueue = [];
+    emitAuthQueue = [];
+    scheduler = null;
+    deletedTwins = [];
+    intervals = {};
+    peripheralTwinMutex = new async_mutex_1.Mutex();
+    eventCallbacks = new Map();
+    reconnectListeners = [];
+    authReconnectListeners = [];
+    constructor(phyhubUrl, deviceId, accessKey, deviceSerial, gridEnv = 'PROD', osVersion = 'N/A', region) {
+        this.phyhubUrl = phyhubUrl;
+        this.deviceId = deviceId;
+        this.accessKey = accessKey;
+        this.deviceSerial = deviceSerial;
+        this.gridEnv = gridEnv.toUpperCase();
+        this.osVersion = osVersion;
+        this.region = region.toUpperCase();
+    }
+    setTwinUpdateHandler(callback) {
+        this.onTwinUpdate = callback;
+    }
+    setTwinRemoveHandler(callback) {
+        this.onTwinRemove = callback;
+    }
+    isConnected() {
+        return this.socketConnected;
+    }
+    isAuthenticated() {
+        return this.socketAuthenticated;
+    }
+    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;
+    }
+    on(event, callback) {
+        const { socket, deviceId } = this;
+        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) => {
+            if (this.isConnected()) {
+                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 });
+    }
+    emit(...args) {
+        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);
+    }
+    emitAuth(...args) {
+        const { socket, emitAuthQueue } = this;
+        if (!socket) {
+            logger.error('emitAuth(): Socket not created');
+            return;
+        }
+        if (!this.isConnected() || !this.isAuthenticated()) {
+            emitAuthQueue.push(args);
+            return;
+        }
+        socket.emit.apply(socket, args);
+    }
+    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();
+    }
+    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);
+        }
+    }
+    executeReconnectListeners() {
+        this.reconnectListeners.forEach(listener => {
+            try {
+                listener();
+            }
+            catch (error) {
+                logger.error('Error executing reconnect listener:', error);
+            }
+        });
+    }
+    executeAuthReconnectListeners() {
+        this.authReconnectListeners.forEach(listener => {
+            try {
+                listener();
+            }
+            catch (error) {
+                logger.error('Error executing reconnect listener:', error);
+            }
+        });
+    }
+    async connectSocket(deviceId, accessKey, phyhubUrl) {
+        const socket = await (0, socket_io_proxy_1.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 (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) => {
+            logger.info('SOCKET connectSocket() on deviceAuthenticated: Device authenticated', response);
+            this.socketAuthenticated = true;
+            if (response.status === 'success') {
+                this.executeReconnectListeners();
+                this.processEmitAuthQueue();
+            }
+            else {
+                logger.error('SOCKET connectSocket() on deviceAuthenticated: Device authentication failed', response);
+            }
+        });
+        socket.io.on('reconnect', (attempt) => {
+            logger.info(`SOCKET connectSocket() on reconnect: Reconnected to server attempt: ${attempt}`);
+            this.socketConnected = true;
+            this.processEmitQueue();
+        });
+        socket.on('twinUpdated', async (payload) => {
+            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) => {
+            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) => {
+            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.io.on('reconnect_attempt', (attempt) => {
+            logger.info(`SOCKET connectSocket() on reconnect_attempt: Reconnect attempt: ${attempt}`);
+        });
+        socket.io.on('reconnect_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;
+    }
+    getDeviceStatus = async () => {
+        const storage = await (0, storage_1.default)();
+        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 = [];
+        const cachedTwins = await this.getCachedTwins();
+        try {
+            const deviceTwinInstanceId = cachedTwins?.[twin_types_1.TwinTypeEnum.Device]?.[0];
+            if (deviceTwinInstanceId) {
+                const deviceTwinInstance = 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;
+    };
+    getDeviceInstance = async () => {
+        const storage = await (0, storage_1.default)();
+        const deviceId = await storage.get('deviceId');
+        const twins = await this.getCachedTwins();
+        try {
+            const deviceTwinInstanceId = twins[twin_types_1.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 {};
+        }
+    };
+    getDeviceNetworks = async () => {
+        try {
+            const sysinfo = await (0, sysinfo_1.default)();
+            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: [],
+            };
+        }
+    };
+    getScreenInstance = async () => {
+        const storage = await (0, storage_1.default)();
+        const deviceId = await storage.get('deviceId');
+        try {
+            const twins = await this.getCachedTwins();
+            console.log('getScreenInstance(): twins', JSON.stringify(twins, null, 2));
+            if (!twins[twin_types_1.TwinTypeEnum.Screen]) {
+                return {};
+            }
+            const screenTwinInstanceId = twins[twin_types_1.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 {};
+        }
+    };
+    async connectDevice(callback) {
+        const { socket, deviceId } = this;
+        logger.info(`connectDevice(): Connecting device ${deviceId}`);
+        if (!socket || !deviceId) {
+            return callback({ error: `connectDevice ${deviceId}: Not connected` });
+        }
+        let deviceTwin = undefined;
+        let cachedTwinsInfo;
+        let shouldUseCachedResponse = false;
+        try {
+            cachedTwinsInfo = await this.getCachedTwins();
+            if (cachedTwinsInfo && cachedTwinsInfo[twin_types_1.TwinTypeEnum.Device] && cachedTwinsInfo[twin_types_1.TwinTypeEnum.Device].length > 0) {
+                const deviceTwinId = cachedTwinsInfo[twin_types_1.TwinTypeEnum.Device][0];
+                deviceTwin = await this.getCachedTwins(deviceTwinId);
+                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 (0, sysinfo_1.default)();
+            let ips = [];
+            try {
+                const { networkInterfaces } = deviceInfo;
+                for (const iface of networkInterfaces) {
+                    if (iface.ip4 && iface.ip4 !== '127.0.0.1') {
+                        ips.push({
+                            interface: iface.ifaceName,
+                            ipv4: iface.ip4,
+                            ipv6: iface.ip6,
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                logger.error('Failed to detect IP address of device', error);
+            }
+            const storage = await (0, storage_1.default)();
+            const isBrowser = typeof window !== 'undefined';
+            let finalOsVersion;
+            if (sysinfo_1.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 = {
+                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) => {
+                logger.info('reportSystemInformation(): Emitted system information');
+            });
+        };
+        reportSystemInformation();
+        if (!this.intervals['reportSystemInformation']) {
+            this.intervals['reportSystemInformation'] = setInterval(async () => {
+                if (!this.isConnected() || !this.isAuthenticated()) {
+                    return;
+                }
+                reportSystemInformation();
+            }, 300000);
+        }
+        const connector = async () => {
+            this.emitAuth('connectDevice', async (response) => {
+                console.log('connector connectDevice(): response', response);
+                if (response.status === 'success' && response.twins) {
+                    callback(response);
+                    const { twins } = response;
+                    logger.info(`SOCKET connector(): received ${twins.length} twins in response.   🟢-🟢-🟢-🟢-🟢`);
+                    await this.cacheTwins(twins);
+                }
+                else if (shouldUseCachedResponse && deviceTwin && cachedTwinsInfo) {
+                    const storage = await (0, storage_1.default)();
+                    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 {
+                    logger.error(`SOCKET connector(): No twins received in response and no cached fallback available.   🟢-🟢-🟢-🟢-🔴`);
+                    callback(response);
+                }
+            });
+        };
+        connector();
+        socket.on('reconnect', connector);
+    }
+    async transformCachedTwinsToArray(cachedTwins) {
+        const transformedTwins = [];
+        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;
+    }
+    cacheTwins = async (twins) => {
+        for (const twin of twins) {
+            try {
+                if (twin.type === twin_types_1.TwinTypeEnum.Peripheral) {
+                    await this.cachePeripheralTwins(twin);
+                    continue;
+                }
+                const { type, id } = twin;
+                if (type === twin_types_1.TwinTypeEnum.Device) {
+                    const reported = twin.properties?.reported;
+                    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 (0, storage_1.default)();
+        const twinsInfo = {};
+        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}`;
+                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) {
+        }
+        if (cachedTwinsInfo) {
+            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];
+                }
+            }
+            await storage.set(twinsInfoCachePath, updatedTwinsInfo);
+        }
+        else {
+            await storage.set(twinsInfoCachePath, twinsInfo);
+        }
+    };
+    async removeCachedTwin(twins) {
+        const storage = await (0, storage_1.default)();
+        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;
+            if (type === twin_types_1.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;
+            }
+            const twinCachePath = `${id}-device-${deviceId}`;
+            const twinsInfoCachePath = `twins-device-${deviceId}`;
+            try {
+                logger.info(`removeCachedTwin(): Removing ${type} twin ${id}`);
+                await storage.remove(twinCachePath);
+                const cachedTwinsInfo = await storage.get(twinsInfoCachePath);
+                if (cachedTwinsInfo && cachedTwinsInfo[type]) {
+                    cachedTwinsInfo[type] = cachedTwinsInfo[type].filter((cachedId) => 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}`);
+            }
+        }
+    }
+    getCachedTwins = async (twinId = undefined) => {
+        const storage = await (0, storage_1.default)();
+        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;
+        }
+    };
+    async reportScreenInstanceProperties(properties, callback) {
+        const { socket, deviceId } = this;
+        if (!socket || !deviceId) {
+            return callback({ error: `reportScreenInstanceProperties() ${deviceId}: Not connected` });
+        }
+        this.emitAuth('reportScreenTwinProperties', properties, async (response) => {
+            if (response.status === PhyHubResponseStatus.success) {
+                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);
+        });
+    }
+    async getEdgeInstance(payload) {
+        const storage = await (0, storage_1.default)();
+        const deviceId = await storage.get('deviceId');
+        try {
+            const { twinId } = payload;
+            const twins = await this.getCachedTwins();
+            const edgeTwin = twins[twin_types_1.TwinTypeEnum.Edge].filter((id) => 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 {};
+        }
+    }
+    async sendEventSignal(payload) {
+        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);
+    }
+    async sendClientSignal(payload) {
+        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);
+    }
+    async sendSessionSignal(payload) {
+        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);
+    }
+    async reportEdgeTwinProperties(instanceTwinId, properties, callback) {
+        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 = {
+            twinId: instanceTwinId,
+            data: properties,
+        };
+        this.emitAuth('reportEdgeTwinProperties', payload, async (response) => {
+            const { twin } = response;
+            if (twin) {
+                await this.cacheTwins([twin]);
+            }
+        });
+    }
+    async reportDeviceTwinProperties(instanceTwinId, properties, callback) {
+        const { socket, deviceId } = this;
+        if (!socket || !deviceId) {
+            return callback({ error: `reportDeviceTwinProperties(): Device or socket not connected` });
+        }
+        const payload = {
+            twinId: instanceTwinId,
+            data: properties,
+        };
+        this.emitAuth('reportDeviceTwinProperties', payload, async (response) => {
+            const { twin } = response;
+            if (twin) {
+                await this.cacheTwins([twin]);
+            }
+        });
+    }
+    async reportDeviceJob(instanceTwinId, job, callback) {
+        const { socket, deviceId } = this;
+        if (!socket || !deviceId) {
+            return callback({ error: `reportDeviceJob(): Device or socket not connected` });
+        }
+        const payload = {
+            twinId: instanceTwinId,
+            data: job,
+        };
+        this.emitAuth('reportDeviceJob', payload, async (response) => {
+            const { twin } = response;
+            if (twin) {
+                await this.cacheTwins([twin]);
+            }
+        });
+    }
+    async reportPeripheralTwinProperties(instanceTwinId, properties, callback) {
+        const { socket, deviceId } = this;
+        if (!socket || !deviceId) {
+            return callback?.({ error: `reportPeripheralTwinProperties(): Device or socket not connected` });
+        }
+        const payload = {
+            twinId: instanceTwinId,
+            data: properties,
+        };
+        this.emitAuth('reportPeripheralTwinProperties', payload, async (response) => {
+            const { twin } = response;
+            if (twin) {
+                await this.cacheTwins([twin]);
+            }
+            callback?.(response);
+        });
+    }
+    setScheduler(scheduler) {
+        this.scheduler = scheduler;
+        if (scheduler && typeof scheduler.setHubDevice === 'function') {
+            scheduler.setHubDevice(this);
+        }
+        logger.info('setScheduler(): Scheduler has been set');
+    }
+    async cachePeripheralTwins(twin) {
+        if (twin.type !== twin_types_1.TwinTypeEnum.Peripheral || !twin.instanceId)
+            return;
+        return await this.peripheralTwinMutex.runExclusive(async () => {
+            const storage = await (0, storage_1.default)();
+            const cachePath = `peripheral-twins-${twin.instanceId}`;
+            let peripheralTwins = await storage.get(cachePath) || {};
+            peripheralTwins[twin.id] = twin;
+            await storage.set(cachePath, peripheralTwins);
+            return peripheralTwins;
+        });
+    }
+    async getPeripheralTwins(payload) {
+        const { data } = payload;
+        if (!data?.instanceId) {
+            logger.error('getPeripheralTwins(): Missing instanceId in payload');
+            return { peripheralTwins: {} };
+        }
+        return await this.peripheralTwinMutex.runExclusive(async () => {
+            const storage = await (0, storage_1.default)();
+            const cachePath = `peripheral-twins-${data.instanceId}`;
+            const cachedTwins = await storage.get(cachePath) || {};
+            try {
+                const response = await new Promise((resolve, reject) => {
+                    this.emitAuth('getPeripheralTwins', payload, resolve);
+                    this.socket?.on('error', reject);
+                });
+                const peripheralTwins = response?.peripheralTwins || {};
+                for (const twin of Object.values(peripheralTwins)) {
+                    await this.cachePeripheralTwins(twin);
+                }
+                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: {} };
+            }
+        });
+    }
+    onReconnect(listener) {
+        this.reconnectListeners.push(listener);
+    }
+    onAuthReconnect(listener) {
+        this.authReconnectListeners.push(listener);
+    }
+}
+exports.HubDevice = HubDevice;
+exports.default = {
+    connectToPhyHub: exports.connectToPhyHub,
+    getPhyHubInstance: exports.getPhyHubInstance,
+    getProvisioningInfo: exports.getProvisioningInfo,
+};
+//# sourceMappingURL=index.js.map