@phystack/device-phyos 4.3.40-dev

package/dist/edge-hub.js

@@ -0,0 +1,1089 @@
+"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.EdgeHubServer = exports.TwinStatusEnum = void 0;
+exports.startEdgeHub = startEdgeHub;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const express_1 = __importDefault(require("express"));
+const http_1 = require("http");
+const socket_io_1 = require("socket.io");
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const hub_device_1 = __importStar(require("@phystack/hub-device"));
+const http_proxy_1 = require("./http-proxy");
+const wifi_1 = require("./methods/network/wifi");
+const lan_1 = require("./methods/network/lan");
+const environment_1 = require("./methods/environment");
+const hostname_1 = require("./methods/network/hostname");
+const phy_logger_1 = require("@phystack/phy-logger");
+const twin_types_1 = require("./types/twin.types");
+const sysinfo_1 = require("./utilities/sysinfo");
+const devdevice_1 = __importDefault(require("./methods/devdevice"));
+const symlink_1 = require("./utilities/symlink");
+const twin_manager_1 = require("./utilities/twin-manager");
+const instances_1 = require("./utilities/instances");
+const ca_1 = require("./methods/network/ca");
+const crypto_1 = require("crypto");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+const logger = new phy_logger_1.PhyLogger({
+    logToFile: false,
+    logToConsole: true,
+    includeTrace: true,
+    namespace: 'edge-hub',
+});
+var TwinStatusEnum;
+(function (TwinStatusEnum) {
+    TwinStatusEnum["Offline"] = "Offline";
+    TwinStatusEnum["Online"] = "Online";
+    TwinStatusEnum["Starting"] = "Starting";
+    TwinStatusEnum["Exited"] = "Exited";
+    TwinStatusEnum["ImageNotFound"] = "ImageNotFound";
+})(TwinStatusEnum || (exports.TwinStatusEnum = TwinStatusEnum = {}));
+class EdgeHubServer {
+    static instance = null;
+    io;
+    connectedModuleSockets = {};
+    gridEnv;
+    osVersion;
+    provisioningCode = 'N/A2';
+    deviceSerial = 'N/A2';
+    config;
+    certPaths;
+    twinManager;
+    twinSubscriptions = new Map();
+    messageDeliveryTracker = new Map();
+    MAX_TRACKED_MESSAGES = 1000;
+    constructor() {
+        this.io = new socket_io_1.Server();
+        this.gridEnv = this.loadGridEnv();
+        this.osVersion = this.loadOsVersion();
+        this.loadDeviceSerial();
+        this.initializeTwinManager();
+        this.config = {
+            certDir: '/usr/local/share/ca-certificates/',
+            certName: 'phyos',
+            moduleMessagingPort: 55000,
+            moduleMessagingPortSSL: 55500,
+            phyDeviceIP: '172.26.128.1',
+            localhostIP: '127.0.0.1',
+        };
+        this.certPaths = this.initializeCertPaths();
+    }
+    static getInstance() {
+        if (!EdgeHubServer.instance) {
+            EdgeHubServer.instance = new EdgeHubServer();
+        }
+        return EdgeHubServer.instance;
+    }
+    loadGridEnv() {
+        try {
+            (0, symlink_1.ensureEnvSymlink)();
+            return fs_1.default.readFileSync('/data/settings/phyos.env', 'utf8').trim() || 'PROD';
+        }
+        catch (err) {
+            logger.error('loadGridEnv(): Error reading GRID_ENV:', err);
+            return 'PROD';
+        }
+    }
+    loadOsVersion() {
+        try {
+            return fs_1.default.readFileSync('/etc/phyos.version', 'utf8').trim() || 'PROD';
+        }
+        catch (err) {
+            logger.error('loadGridEnv(): Error reading GRID_ENV:', err);
+            return 'PROD';
+        }
+    }
+    loadDeviceSerial() {
+    }
+    initializeCertPaths() {
+        const { certDir, certName } = this.config;
+        const caCertName = `${certName}-ca`;
+        return {
+            ca: path_1.default.join(certDir, `${caCertName}.crt`),
+            caKey: path_1.default.join(certDir, `${caCertName}.key`),
+            cert: path_1.default.join(certDir, `${certName}.crt`),
+            key: path_1.default.join(certDir, `${certName}.key`),
+        };
+    }
+    async generateCertificates() {
+        logger.info('generateCertificates(): Generating CA and self-signed certificate...');
+        const { ca, caKey, cert, key } = this.certPaths;
+        const csr = path_1.default.join(this.config.certDir, `${this.config.certName}.csr`);
+        const hasValidContent = (filePath) => {
+            try {
+                const content = fs_1.default.readFileSync(filePath, 'utf8');
+                return content.length > 0;
+            }
+            catch {
+                return false;
+            }
+        };
+        if (fs_1.default.existsSync(ca) &&
+            fs_1.default.existsSync(caKey) &&
+            fs_1.default.existsSync(cert) &&
+            fs_1.default.existsSync(key) &&
+            fs_1.default.existsSync(csr) &&
+            hasValidContent(ca) &&
+            hasValidContent(caKey) &&
+            hasValidContent(cert) &&
+            hasValidContent(key) &&
+            hasValidContent(csr)) {
+            logger.info('generateCertificates(): CA and certificates already exist. Skipping generation.');
+            return true;
+        }
+        try {
+            const caCertName = `${this.config.certName}-ca`;
+            const certName = this.config.certName;
+            const certDir = this.config.certDir;
+            await execAsync(`openssl req -x509 -nodes -newkey rsa:4096 -keyout ${caKey} ` +
+                `-out ${ca} -days 365 -subj "/CN=${caCertName}/O=Phygrid"`);
+            logger.info('generateCertificates(): CA generated successfully.');
+            await execAsync(`openssl req -newkey rsa:4096 -nodes -keyout ${key} ` +
+                `-out ${certDir}/${certName}.csr -subj "/CN=${certName}/O=Phygrid" && ` +
+                `openssl x509 -req -in ${certDir}/${certName}.csr -CA ${ca} ` +
+                `-CAkey ${caKey} -CAcreateserial -out ${cert} -days 365`);
+            logger.info('generateCertificates(): Certificate generated successfully.');
+            await execAsync('update-ca-certificates');
+            logger.info('generateCertificates(): CA added to system trust.');
+            return true;
+        }
+        catch (error) {
+            logger.error('generateCertificates(): Failed to generate certificates:', error);
+            return false;
+        }
+    }
+    async waitForIP(ip) {
+        logger.info('waitForIP(): Waiting for IP:', ip);
+        while (true) {
+            try {
+                const { stdout } = await execAsync(`ip a | grep ${ip}`);
+                if (stdout.includes(ip))
+                    return;
+            }
+            catch (error) {
+                await new Promise(resolve => setTimeout(resolve, 100));
+            }
+        }
+    }
+    async getDeviceStatus() {
+        const phyHub = await (0, hub_device_1.getPhyHubInstance)();
+        if (!phyHub) {
+            logger.warn('getDeviceStatus(): No phyHub instance, returning offline status.');
+            const provisioningInfo = await hub_device_1.default.getProvisioningInfo();
+            this.deviceSerial = provisioningInfo.deviceSerial;
+            this.provisioningCode = provisioningInfo.provisioningCode;
+            const response = {
+                status: 'success',
+                gridEnv: this.gridEnv,
+                osVersion: this.osVersion,
+                isConnected: 'false',
+                socketAuthenticated: false,
+                socketConnected: false,
+                ...provisioningInfo,
+            };
+            return response;
+        }
+        const system = await phyHub.getDeviceStatus();
+        if (system.displayName) {
+            try {
+                (0, hostname_1.updateHostname)(system.displayName);
+            }
+            catch (error) {
+                logger.error(`getDeviceStatus(): Failed to update hostname to: ${system.displayName}:`, error);
+            }
+        }
+        this.deviceSerial = system.deviceSerial;
+        this.provisioningCode = system.provisioningCode;
+        const response = {
+            status: 'success',
+            isConnected: 'true',
+            ...system,
+        };
+        return response;
+    }
+    handleNetworkConfig(payload, configType) {
+        const { data } = payload;
+        if (!data) {
+            return { status: 'error', message: 'Invalid configuration data' };
+        }
+        switch (configType) {
+            case 'wireless':
+                return (0, wifi_1.configureWirelessNetwork)(data);
+            case 'wired':
+                return (0, lan_1.configureWiredNetwork)(data);
+            case 'proxy':
+                return (0, environment_1.setEnvironmentConfiguration)(data);
+        }
+    }
+    async getScreenInstance() {
+        logger.info(`getScreenInstance(): Getting screen instance`);
+        const phyHub = await (0, hub_device_1.getPhyHubInstance)();
+        if (!phyHub) {
+            try {
+                const provisioningCode = await fs_1.default.promises.readFile('/tmp/provisioning_code');
+                return { status: 'success', isConnected: 'false', provisioningCode };
+            }
+            catch (err) {
+                logger.error('getStatus(): Failed to read provisioning code:', err);
+                return { status: 'success', isConnected: 'false' };
+            }
+        }
+        const screenInstance = await phyHub.getScreenInstance();
+        if (!screenInstance.twin || !screenInstance.twin.properties?.desired) {
+            logger.warn('getScreenInstance(): No screen twin found or missing desired properties');
+            return {
+                status: 'error',
+                message: 'No screen twin configuration available',
+                isConnected: 'true'
+            };
+        }
+        return { status: 'success', ...screenInstance };
+    }
+    async getDeviceInstance() {
+        logger.info(`getDeviceInstance(): Getting device instance`);
+        const phyHub = await (0, hub_device_1.getPhyHubInstance)();
+        if (!phyHub) {
+            const { gridEnv, osVersion } = this;
+            const provisioningInfo = await hub_device_1.default.getProvisioningInfo();
+            return {
+                status: 'success',
+                gridEnv,
+                osVersion,
+                isConnected: 'false',
+                provisioningCode: provisioningInfo.provisioningCode
+            };
+        }
+        const deviceTwin = phyHub ? await phyHub.getDeviceInstance() : null;
+        return { status: 'success', ...deviceTwin };
+    }
+    async getDeviceNetworks() {
+        logger.info(`getDeviceNetworks(): Getting device networks`);
+        try {
+            const deviceNetworks = await (0, sysinfo_1.getDeviceNetworks)();
+            return { status: 'success', data: deviceNetworks };
+        }
+        catch (error) {
+            logger.error('getDeviceNetworks(): Failed to get device networks:', error);
+            return { status: 'error', data: {
+                    wifiNetworks: [],
+                    wifiConnections: [],
+                    networkInterfaces: [],
+                    wifiInterfaces: [],
+                } };
+        }
+    }
+    async setScreenInstanceReportedProperties(payload) {
+        const phyHub = await (0, hub_device_1.getPhyHubInstance)();
+        if (!phyHub) {
+            try {
+                const provisioningCode = await fs_1.default.promises.readFile('/tmp/provisioning_code');
+                return { status: 'success', isConnected: 'false', provisioningCode };
+            }
+            catch (err) {
+                logger.error('setScreenInstanceReportedProperties(): Failed to read provisioning code:', err);
+                return { status: 'success', isConnected: 'false' };
+            }
+        }
+        return new Promise((resolve, reject) => {
+            try {
+                phyHub.reportScreenInstanceProperties(payload, (response) => {
+                    resolve(response);
+                });
+            }
+            catch (error) {
+                logger.error('Error in reportScreenInstanceProperties', error);
+                reject(error);
+            }
+        });
+    }
+    async getEdgeInstance(payload) {
+        logger.info(`getEdgeInstance(): Get edge instance ${JSON.stringify(payload)}`);
+        const phyHub = await (0, hub_device_1.getPhyHubInstance)();
+        if (!phyHub) {
+            return { status: 'error', isConnected: 'false' };
+        }
+        const edgeInstance = await phyHub.getEdgeInstance(payload);
+        return { status: 'success', ...edgeInstance };
+    }
+    async sendEventSignal(payload) {
+        logger.info(`sendEventSignal(): Send Event Signal`);
+        const phyHub = await (0, hub_device_1.getPhyHubInstance)();
+        if (!phyHub) {
+            return { status: 'error', isConnected: 'false' };
+        }
+        await phyHub.sendEventSignal(payload);
+        return { status: 'success' };
+    }
+    async sendSessionSignal(payload) {
+        logger.info(`sendSessionSignal(): Send Session Signal`);
+        const phyHub = await (0, hub_device_1.getPhyHubInstance)();
+        if (!phyHub) {
+            return { status: 'error', isConnected: 'false' };
+        }
+        await phyHub.sendSessionSignal(payload);
+        return { status: 'success' };
+    }
+    async sendClientSignal(payload) {
+        logger.info(`sendClientSignal(): Send Client Signal`);
+        const phyHub = await (0, hub_device_1.getPhyHubInstance)();
+        if (!phyHub) {
+            return { status: 'error', isConnected: 'false' };
+        }
+        await phyHub.sendClientSignal(payload);
+        return { status: 'success' };
+    }
+    async initializeTwinManager() {
+        this.twinManager = await (0, twin_manager_1.getTwinManagerInstance)();
+    }
+    async handleInstanceMessage(hubClientId, payload, callback) {
+        if (payload.method !== 'getDeviceStatus') {
+            logger.info(`handleInstanceMessage(): Received message: ${JSON.stringify({ hubClientId, payload })}`);
+        }
+        const { method } = payload;
+        let result;
+        switch (method) {
+            case 'setWirelessNetwork':
+                result = this.handleNetworkConfig(payload, 'wireless');
+                break;
+            case 'setLanNetwork':
+                result = this.handleNetworkConfig(payload, 'wired');
+                break;
+            case 'setProxy':
+                result = this.handleNetworkConfig(payload, 'proxy');
+                break;
+            case 'ping':
+                result = await this.handlePing(payload);
+                break;
+            case 'reboot':
+                result = await this.handleReboot();
+                break;
+            case 'setEnv':
+                result = await this.handleSetEnv(payload);
+                if (callback)
+                    callback(result);
+                if (result.status === 'success') {
+                    setTimeout(() => {
+                        logger.info('handleInstanceMessage(): Exiting after env change...');
+                        process.exit(0);
+                    }, 1000);
+                }
+                break;
+            case 'getDeviceStatus':
+                result = await this.getDeviceStatus();
+                break;
+            case 'getScreenInstance':
+                result = await this.getScreenInstance();
+                break;
+            case 'getDeviceInstance':
+                result = await this.getDeviceInstance();
+                break;
+            case 'getDeviceNetworks':
+                result = await this.getDeviceNetworks();
+                break;
+            case 'setScreenInstanceReportedProperties':
+                result = await this.setScreenInstanceReportedProperties(payload);
+                break;
+            case 'getEdgeInstance':
+                result = await this.getEdgeInstance(payload);
+                break;
+            case 'sendEventSignal':
+                result = await this.sendEventSignal(payload);
+                break;
+            case 'sendSessionSignal':
+                result = await this.sendSessionSignal(payload);
+                break;
+            case 'sendClientSignal':
+                result = await this.sendClientSignal(payload);
+                break;
+            case 'callModule':
+                result = await this.handleCallModule(payload, callback);
+                break;
+            case 'devdevice':
+                try {
+                    await (0, devdevice_1.default)(payload);
+                    result = { status: 'success', message: 'Developer mode enabled successfully' };
+                }
+                catch (error) {
+                    logger.error('handleInstanceMessage(): Failed to enable developer mode:', error);
+                    result = { status: 'error', message: 'Failed to enable developer mode' };
+                }
+                break;
+            case 'twinMessage':
+                result = await this.handleTwinMessage(payload, callback);
+                break;
+            case 'twinUpdated':
+                result = await this.handleTwinUpdated(payload, callback);
+                break;
+            case 'createLocalTwin': {
+                try {
+                    const twinData = payload.data;
+                    if (!twinData?.twin) {
+                        throw new Error('Twin data is required');
+                    }
+                    const config = {
+                        type: twin_types_1.TwinTypeEnum.Edge,
+                        properties: {
+                            desired: {
+                                ...twinData.twin.properties?.desired,
+                                image: twinData.twin.properties?.desired?.image
+                            }
+                        }
+                    };
+                    logger.info('Creating local twin with config:', config);
+                    const twinId = await this.twinManager.getLocalTwinManager().createLocalTwin(config);
+                    logger.info('Twin created with ID:', twinId);
+                    const newTwin = await this.twinManager.getCachedTwins(twinId);
+                    logger.info('Retrieved twin from cache:', newTwin);
+                    if (newTwin) {
+                        await (0, instances_1.updateInstances)(this.twinManager, [newTwin]);
+                        result = { status: 'success', twin: newTwin };
+                    }
+                    else {
+                        throw new Error('Failed to create twin');
+                    }
+                }
+                catch (error) {
+                    logger.error('Failed to create local twin:', error);
+                    result = { status: 'error', message: error?.message || 'Unknown error' };
+                }
+                break;
+            }
+            case 'removeLocalTwin': {
+                try {
+                    const twinData = payload.data;
+                    if (!twinData?.twinId) {
+                        throw new Error('Twin ID is required');
+                    }
+                    logger.info(`handleInstanceMessage(): Removing local twin ${twinData.twinId}`, twinData);
+                    const twin = await this.twinManager.getCachedTwins(twinData.twinId);
+                    if (!twin) {
+                        throw new Error('Twin not found');
+                    }
+                    logger.info(`handleInstanceMessage(): Stopping container for twin ${twinData.twinId}`);
+                    try {
+                        await (0, instances_1.removeInstances)(this.twinManager, [twin]);
+                    }
+                    catch (error) {
+                        logger.error(`handleInstanceMessage(): Error removing container:`, error);
+                        throw new Error(`Failed to remove container: ${error.message || 'Unknown error'}`);
+                    }
+                    await new Promise(resolve => setTimeout(resolve, 1000));
+                    logger.info(`handleInstanceMessage(): Removing twin ${twinData.twinId} from storage`);
+                    await this.twinManager.getLocalTwinManager().removeCachedTwin(twinData.twinId);
+                    await (0, instances_1.updateInstances)(this.twinManager, [await this.twinManager.getCachedTwins(twinData.twinId)]);
+                    logger.info(`handleInstanceMessage(): Successfully removed twin ${twinData.twinId}`);
+                    result = { status: 'success' };
+                }
+                catch (error) {
+                    logger.error(`handleInstanceMessage(): Error removing local twin:`, error);
+                    result = { status: 'error', message: error?.message || 'Unknown error' };
+                }
+                break;
+            }
+            case 'listLocalTwins':
+                try {
+                    const twins = await this.twinManager.getAllLocalTwins();
+                    result = { status: 'success', twins };
+                }
+                catch (error) {
+                    result = { status: 'error', message: error?.message || 'Unknown error' };
+                }
+                break;
+            case 'setCACertificate':
+                try {
+                    const config = payload.data;
+                    if (!config)
+                        throw new Error('Missing CA certificate configuration');
+                    result = await (0, ca_1.configureCACertificate)(config);
+                }
+                catch (error) {
+                    console.error('Error configuring CA certificate:', error);
+                    result = { status: 'error', error };
+                }
+                break;
+            case 'getTwinById':
+                try {
+                    const { twinId } = payload.data;
+                    if (!twinId) {
+                        result = { status: 'error', message: 'Twin ID is required' };
+                        break;
+                    }
+                    const localTwin = await this.twinManager.getCachedTwins(twinId);
+                    if (localTwin) {
+                        result = { status: 'success', twin: localTwin };
+                        break;
+                    }
+                    const phyHub = await (0, hub_device_1.getPhyHubInstance)();
+                    if (!phyHub) {
+                        result = { status: 'error', message: 'PhyHub instance not found' };
+                        break;
+                    }
+                    result = await new Promise((resolve) => {
+                        phyHub.emitAuth('getTwinById', payload, (response) => {
+                            resolve(response);
+                        });
+                    });
+                }
+                catch (error) {
+                    result = { status: 'error', message: error?.message || 'Unknown error' };
+                }
+                break;
+            default:
+                switch (method) {
+                    case 'twinSubscribe':
+                        if (payload.twinId) {
+                            await this.handleTwinSubscribe(hubClientId, payload.twinId);
+                        }
+                        break;
+                    case 'twinUnsubscribe':
+                        if (payload.twinId) {
+                            await this.handleTwinUnsubscribe(hubClientId, payload.twinId);
+                        }
+                        break;
+                }
+                const phyHub = await (0, hub_device_1.getPhyHubInstance)();
+                if (!phyHub) {
+                    result = { status: 'error', message: 'PhyHub instance not found' };
+                    break;
+                }
+                result = await new Promise((resolve) => {
+                    phyHub.emitAuth(method, payload, (response) => {
+                        resolve(response);
+                    });
+                });
+        }
+        if (callback && result)
+            callback(result);
+        return result;
+    }
+    async handlePing(payload) {
+        const { data, targetInstanceId } = payload;
+        if (!data) {
+            return { status: 'error', message: 'Empty payload' };
+        }
+        if (!targetInstanceId) {
+            return { status: 'error', message: 'Target instance id is undefined' };
+        }
+        logger.info(`handlePing(): Ping called: ${{ targetInstanceId }}`);
+        if (!targetInstanceId || !this.connectedModuleSockets[targetInstanceId] ||
+            this.connectedModuleSockets[targetInstanceId].length === 0) {
+            return { status: 'error', message: 'Target module not found' };
+        }
+        this.connectedModuleSockets[targetInstanceId].forEach(socket => {
+            socket.emit('pong');
+        });
+        return { status: 'success', message: 'Ping initiated' };
+    }
+    async handleReboot() {
+        logger.info('handleReboot(): Initiating device reboot');
+        try {
+            const cmd = (0, child_process_1.spawn)('/usr/bin/systemctl', ['reboot']);
+            return { status: 'success', message: 'Device reboot initiated' };
+        }
+        catch (error) {
+            logger.error('handleReboot(): Failed to reboot device:', error);
+            return { status: 'error', message: 'Failed to reboot device' };
+        }
+    }
+    async handleSetEnv(payload) {
+        const { data } = payload;
+        if (!data?.env) {
+            return { status: 'error', message: 'No environment specified' };
+        }
+        if (data.env === this.gridEnv) {
+            return { status: 'error', message: `Environment is already ${data.env}` };
+        }
+        try {
+            try {
+                await execAsync('systemctl disable physcreen');
+                await execAsync('systemctl stop physcreen');
+            }
+            catch (error) {
+                logger.error('handleSetEnv(): Failed to disable physcreen service:', error);
+            }
+            try {
+                logger.info('handleSetEnv(): Removing existing settings directory');
+                await execAsync('sudo rm -rf /data/settings/phyhub');
+                logger.info('handleSetEnv(): Settings directory removed successfully');
+            }
+            catch (error) {
+                logger.error('handleSetEnv(): Failed to remove settings directory:', error);
+                return {
+                    status: 'error',
+                    message: `Failed to remove settings: ${error.message}`
+                };
+            }
+            try {
+                logger.info('handleSetEnv(): Clearing environment file contents');
+                await execAsync('echo -n > /data/settings/environment');
+                logger.info('handleSetEnv(): Environment file cleared successfully');
+            }
+            catch (error) {
+                logger.error('handleSetEnv(): Failed to clear environment file:', error);
+                return {
+                    status: 'error',
+                    message: `Failed to clear environment file: ${error.message}`
+                };
+            }
+            const symlinkFixed = (0, symlink_1.ensureEnvSymlink)();
+            fs_1.default.writeFileSync('/data/settings/phyos.env', data.env);
+            logger.info(`handleSetEnv(): Environment updated to ${data.env}${symlinkFixed ? ' and symlink fixed' : ''}`);
+            try {
+                setTimeout(async () => {
+                    await execAsync('systemctl restart phydevice');
+                    logger.info('handleSetEnv(): Restarted phydevice service');
+                }, 2000);
+            }
+            catch (error) {
+                logger.error('handleSetEnv(): Failed to restart phydevice service:', error);
+            }
+            return { status: 'success', message: `Environment set to ${data.env}` };
+        }
+        catch (error) {
+            logger.error('handleSetEnv(): Failed to update environment:', error);
+            return {
+                status: 'error',
+                message: `Failed to set environment: ${error.message}`
+            };
+        }
+    }
+    async handleCallModule(payload, callback) {
+        const { data, targetMethod, targetInstanceId } = payload;
+        if (!targetInstanceId || !this.connectedModuleSockets[targetInstanceId] ||
+            this.connectedModuleSockets[targetInstanceId].length === 0) {
+            logger.error(`handleCallModule(): Target ${targetInstanceId} not found`);
+            return { status: 'error', message: 'Target module not found' };
+        }
+        const payloadToEmit = {
+            data: payload.data,
+        };
+        this.connectedModuleSockets[targetInstanceId].forEach(socket => {
+            socket.emit(targetMethod, payloadToEmit, callback);
+        });
+        return { status: 'success', message: 'Call module sent' };
+    }
+    setupSocketHandlers(socket) {
+        const { instanceId: instanceIdFromAuth, moduleName: moduleNameFromAuth } = socket.auth;
+        const hubClientId = instanceIdFromAuth || moduleNameFromAuth;
+        if (!hubClientId) {
+            return;
+        }
+        logger.info(`setupSocketHandlers(): Client ${hubClientId} connected`);
+        if (!this.connectedModuleSockets[hubClientId]) {
+            this.connectedModuleSockets[hubClientId] = [];
+        }
+        this.connectedModuleSockets[hubClientId].push(socket);
+        socket.join(hubClientId);
+        socket.on('disconnect', () => {
+            logger.info(`setupSocketHandlers(): Client ${hubClientId} disconnected`);
+            if (this.connectedModuleSockets[hubClientId]) {
+                const index = this.connectedModuleSockets[hubClientId].indexOf(socket);
+                if (index !== -1) {
+                    this.connectedModuleSockets[hubClientId].splice(index, 1);
+                }
+                if (this.connectedModuleSockets[hubClientId].length === 0) {
+                    delete this.connectedModuleSockets[hubClientId];
+                }
+            }
+        });
+        socket.on(hubClientId, async (payload, callback) => {
+            await this.handleInstanceMessage(hubClientId, payload, callback);
+        });
+        socket.on('reconnect', () => {
+            logger.info(`setupSocketHandlers(): Client ${hubClientId} reconnected`);
+            socket.join(hubClientId);
+        });
+        socket.on('getDeviceTwin', (callback) => {
+            callback({ example: 'deviceTwin' });
+        });
+        socket.on('ping', (data) => {
+            setTimeout(() => {
+                socket.emit('pong', { count: data.count + 1 });
+            }, 3000);
+        });
+    }
+    setupExpressApp() {
+        const app = (0, express_1.default)();
+        app.get('/', (_req, res) => {
+            res.json({ hello: 'world' });
+        });
+        app.get('/status', (_req, res) => {
+            res.json({ status: 'ok' });
+        });
+        return app;
+    }
+    async setupProxyServers(sslEnabled) {
+        const { localhostIP, phyDeviceIP, moduleMessagingPort, moduleMessagingPortSSL } = this.config;
+        const { key: keyPath, cert: certPath } = this.certPaths;
+        if (sslEnabled) {
+            (0, http_proxy_1.startProxyServer)({
+                sourceIp: localhostIP,
+                sourcePort: moduleMessagingPort,
+                destIp: localhostIP,
+                destPort: moduleMessagingPortSSL,
+                useHttps: true,
+                keyPath,
+                certPath,
+            });
+        }
+        await this.waitForIP(phyDeviceIP);
+        (0, http_proxy_1.startProxyServer)({
+            sourceIp: localhostIP,
+            sourcePort: moduleMessagingPort,
+            destIp: phyDeviceIP,
+            destPort: moduleMessagingPort,
+            useHttps: false,
+        });
+        if (sslEnabled) {
+            (0, http_proxy_1.startProxyServer)({
+                sourceIp: localhostIP,
+                sourcePort: moduleMessagingPort,
+                destIp: phyDeviceIP,
+                destPort: moduleMessagingPortSSL,
+                useHttps: true,
+                keyPath,
+                certPath,
+            });
+        }
+    }
+    async start() {
+        logger.info('start(): Starting edge hub messaging...');
+        let sslEnabled = await this.generateCertificates();
+        this.io.use((socket, next) => {
+            const extSocket = socket;
+            const { auth } = socket.handshake;
+            extSocket.auth = auth;
+            next();
+        });
+        this.io.on('connection', (socket) => {
+            this.setupSocketHandlers(socket);
+        });
+        const app = this.setupExpressApp();
+        const { localhostIP, moduleMessagingPort } = this.config;
+        const httpServerLocal = (0, http_1.createServer)(app);
+        this.io.attach(httpServerLocal);
+        httpServerLocal.listen(moduleMessagingPort, localhostIP, () => {
+            logger.info(`start(): edgeHub Messaging HTTP Server listening on http://${localhostIP}:${moduleMessagingPort}`);
+        });
+        setTimeout(() => this.setupProxyServers(sslEnabled), 0);
+    }
+    generateMessageId(payload) {
+        const { twinId, sourceTwinId, method, data } = payload;
+        const timestamp = Math.floor(Date.now() / 3000) * 3;
+        const dataString = data ? JSON.stringify(data, (_, v) => Buffer.isBuffer(v) ? v.toString('base64') : v) : '';
+        const hash = (0, crypto_1.createHash)('sha256')
+            .update(`${twinId}-${sourceTwinId}-${method}-${dataString}-${timestamp}`)
+            .digest('hex');
+        return hash;
+    }
+    trackMessageDelivery(messageId, recipientId) {
+        if (!this.messageDeliveryTracker.has(messageId)) {
+            this.messageDeliveryTracker.set(messageId, new Set());
+            if (this.messageDeliveryTracker.size > this.MAX_TRACKED_MESSAGES) {
+                const oldestKey = this.messageDeliveryTracker.keys().next().value;
+                if (oldestKey) {
+                    this.messageDeliveryTracker.delete(oldestKey);
+                }
+            }
+        }
+        this.messageDeliveryTracker.get(messageId).add(recipientId);
+    }
+    hasMessageBeenDelivered(messageId, recipientId) {
+        return this.messageDeliveryTracker.get(messageId)?.has(recipientId) || false;
+    }
+    async handleTwinMessage(payload, callback, fromPhyHub = false) {
+        const phyHub = await (0, hub_device_1.getPhyHubInstance)();
+        if (!phyHub) {
+            logger.error('handleTwinMessage(): PhyHub instance not found');
+            if (callback)
+                callback({ status: 'error', message: 'PhyHub instance not found' });
+            return { status: 'error', message: 'PhyHub instance not found' };
+        }
+        const { twinId, sourceTwinId } = payload;
+        if (!twinId && !sourceTwinId) {
+            logger.error('handleTwinMessage(): No twin ID provided');
+            return { status: 'error', message: 'No twin ID provided' };
+        }
+        const deviceTwins = await phyHub.getCachedTwins();
+        const messageId = this.generateMessageId(payload);
+        let messageForwardedToPhyHub = false;
+        if (twinId === sourceTwinId) {
+            if (!fromPhyHub) {
+                messageForwardedToPhyHub = true;
+                this.forwardToPhyHub(payload, callback);
+            }
+        }
+        this.twinSubscriptions.forEach((subscribedTwins, subscriberTwinId) => {
+            if (subscribedTwins.has(twinId) && !this.hasMessageBeenDelivered(messageId, subscriberTwinId)) {
+                this.io.to(subscriberTwinId).emit('twinMessage', payload);
+                this.trackMessageDelivery(messageId, subscriberTwinId);
+            }
+            else {
+                logger.info(`handleTwinMessage(): No match found for twinId ${twinId} in subscriber ${subscriberTwinId}`);
+            }
+        });
+        if (deviceTwins['Edge']) {
+            for (const edgeTwinId of deviceTwins['Edge']) {
+                const edgeTwin = await phyHub.getCachedTwins(edgeTwinId);
+                const { id: instanceId } = edgeTwin;
+                if (instanceId === twinId && !this.hasMessageBeenDelivered(messageId, instanceId)) {
+                    this.io.to(instanceId).emit('twinMessage', payload, callback);
+                    this.trackMessageDelivery(messageId, instanceId);
+                }
+            }
+        }
+        if (deviceTwins['Screen']) {
+            for (const screenTwinId of deviceTwins['Screen']) {
+                const screenTwin = await phyHub.getCachedTwins(screenTwinId);
+                const { id: instanceId } = screenTwin;
+                if (instanceId === twinId && !this.hasMessageBeenDelivered(messageId, instanceId)) {
+                    this.io.to(instanceId).emit('twinMessage', payload, callback);
+                    this.trackMessageDelivery(messageId, instanceId);
+                }
+            }
+        }
+        if (deviceTwins['Peripheral']) {
+            for (const peripheralTwinId of deviceTwins['Peripheral']) {
+                const peripheralTwin = await phyHub.getCachedTwins(peripheralTwinId);
+                const { instanceId } = peripheralTwin.properties.desired;
+                if (instanceId && deviceTwins['Edge'].includes(instanceId) && !this.hasMessageBeenDelivered(messageId, instanceId)) {
+                    this.io.to(instanceId).emit('twinMessage', payload);
+                    this.trackMessageDelivery(messageId, instanceId);
+                }
+            }
+        }
+        if (!messageForwardedToPhyHub && !fromPhyHub) {
+            const result = await this.forwardToPhyHub(payload, callback);
+            if (callback)
+                callback(result);
+            return result;
+        }
+        if (callback)
+            callback({ status: 'error', message: 'Message not forwarded' });
+        return { status: 'error', message: 'Message not forwarded' };
+    }
+    async forwardToPhyHub(payload, callback) {
+        const phyHub = await (0, hub_device_1.getPhyHubInstance)();
+        if (!phyHub) {
+            logger.error('forwardToPhyHub(): PhyHub instance not found');
+            return;
+        }
+        const { twinId } = payload;
+        const uuidV4Pattern = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+        const isLocalTwin = twinId && uuidV4Pattern.test(twinId);
+        if (isLocalTwin) {
+            return { status: 'success' };
+        }
+        return new Promise((resolve) => {
+            phyHub.emitAuth('twinMessage', payload, (response) => {
+                if (callback)
+                    callback(response);
+                resolve(response);
+            });
+        });
+    }
+    async handleTwinSubscribe(subscriberTwinId, targetTwinId) {
+        console.log('handleTwinSubscribe(): subscriberTwinId', JSON.stringify({ subscriberTwinId, targetTwinId }, null, 2));
+        if (!this.twinSubscriptions.has(subscriberTwinId)) {
+            console.log('handleTwinSubscribe(): Setting new subscription', subscriberTwinId);
+            this.twinSubscriptions.set(subscriberTwinId, new Set());
+        }
+        this.twinSubscriptions.get(subscriberTwinId).add(targetTwinId);
+        logger.info(`handleTwinSubscribe(): Twin ${subscriberTwinId} subscribed to ${targetTwinId}`);
+    }
+    async handleTwinUnsubscribe(subscriberTwinId, targetTwinId) {
+        const subscriptions = this.twinSubscriptions.get(subscriberTwinId);
+        if (subscriptions) {
+            subscriptions.delete(targetTwinId);
+            if (subscriptions.size === 0) {
+                this.twinSubscriptions.delete(subscriberTwinId);
+            }
+            logger.info(`handleTwinUnsubscribe(): Twin ${subscriberTwinId} unsubscribed from ${targetTwinId}`);
+        }
+    }
+    async resubscribeAllTwins() {
+        logger.info('resubscribeAllTwins(): Starting resubscription process');
+        const phyHub = await (0, hub_device_1.getPhyHubInstance)();
+        if (!phyHub) {
+            logger.error('resubscribeAllTwins(): PhyHub instance not found');
+            return;
+        }
+        const deviceStatus = await this.getDeviceStatus();
+        if (!deviceStatus?.deviceId) {
+            logger.error('resubscribeAllTwins(): Device ID not found');
+            return;
+        }
+        logger.info('resubscribeAllTwins(): Current subscriptions:', Object.fromEntries([...this.twinSubscriptions].map(([k, v]) => [k, [...v]])));
+        if (this.twinSubscriptions.size === 0) {
+            logger.info('resubscribeAllTwins(): No existing subscriptions to resubscribe');
+            return;
+        }
+        for (const [subscriberTwinId, subscribedTwins] of this.twinSubscriptions.entries()) {
+            logger.info(`resubscribeAllTwins(): Processing subscriber ${subscriberTwinId} with ${subscribedTwins.size} subscriptions`);
+            for (const targetTwinId of subscribedTwins) {
+                logger.info(`resubscribeAllTwins(): Attempting to resubscribe ${subscriberTwinId} to ${targetTwinId}`);
+                const payload = {
+                    twinId: targetTwinId,
+                    sourceTwinId: subscriberTwinId,
+                    sourceDeviceId: deviceStatus.deviceId
+                };
+                try {
+                    const response = await new Promise((resolve, reject) => {
+                        phyHub.emitAuth('twinSubscribe', payload, (response) => {
+                            if (response.status === 'success') {
+                                resolve(response);
+                            }
+                            else {
+                                reject(new Error(response.message || 'Unknown error'));
+                            }
+                        });
+                    });
+                    console.log('resubscribeAllTwins(): Response', JSON.stringify(response, null, 2));
+                    logger.info(`resubscribeAllTwins(): Successfully resubscribed ${subscriberTwinId} to ${targetTwinId}`);
+                }
+                catch (error) {
+                    logger.error(`resubscribeAllTwins(): Failed to resubscribe ${subscriberTwinId} to ${targetTwinId}:`, error);
+                }
+            }
+        }
+    }
+    async handleTwinUpdated(payload, callback, fromPhyHub = false) {
+        logger.info('handleTwinUpdated(): Received twin update', JSON.stringify(payload, null, 2));
+        const phyHub = await (0, hub_device_1.getPhyHubInstance)();
+        if (!phyHub) {
+            logger.error('handleTwinUpdated(): PhyHub instance not found');
+            if (callback)
+                callback({ status: 'error', message: 'PhyHub instance not found' });
+            return { status: 'error', message: 'PhyHub instance not found' };
+        }
+        let { twinId, sourceTwinId } = payload;
+        if (!twinId && payload.data?.id) {
+            twinId = payload.data.id;
+            logger.info(`handleTwinUpdated(): Using data.id ${twinId} as twinId`);
+        }
+        if (!twinId && !sourceTwinId) {
+            logger.error('handleTwinUpdated(): No twin ID provided');
+            return { status: 'error', message: 'No twin ID provided' };
+        }
+        const deviceTwins = await phyHub.getCachedTwins();
+        const messageId = this.generateMessageId(payload);
+        let emissionCount = 0;
+        const subscriberCount = this.twinSubscriptions.size;
+        let subscriberEmitCount = 0;
+        this.twinSubscriptions.forEach((subscribedTwins, subscriberTwinId) => {
+            if (subscribedTwins.has(twinId) && !this.hasMessageBeenDelivered(messageId, subscriberTwinId)) {
+                this.io.to(subscriberTwinId).emit('twinUpdated', payload);
+                this.trackMessageDelivery(messageId, subscriberTwinId);
+                subscriberEmitCount++;
+                emissionCount++;
+                logger.info(`handleTwinUpdated(): Emitted to subscriber ${subscriberTwinId} for twin ${twinId}`);
+            }
+        });
+        if (subscriberCount > 0 && subscriberEmitCount === 0) {
+            logger.info(`handleTwinUpdated(): No subscribers matched twin ${twinId} (out of ${subscriberCount} total subscribers)`);
+        }
+        let edgeEmitCount = 0;
+        if (deviceTwins['Edge']) {
+            for (const edgeTwinId of deviceTwins['Edge']) {
+                const edgeTwin = await phyHub.getCachedTwins(edgeTwinId);
+                const { id: instanceId } = edgeTwin;
+                if (instanceId === twinId && !this.hasMessageBeenDelivered(messageId, instanceId)) {
+                    this.io.to(instanceId).emit('twinUpdated', payload, callback);
+                    this.trackMessageDelivery(messageId, instanceId);
+                    edgeEmitCount++;
+                    emissionCount++;
+                    logger.info(`handleTwinUpdated(): Emitted to Edge twin ${instanceId}`);
+                }
+            }
+            if (edgeEmitCount === 0) {
+                logger.info(`handleTwinUpdated(): No Edge twins matched twin ${twinId} (out of ${deviceTwins['Edge'].length} Edge twins)`);
+            }
+        }
+        let screenEmitCount = 0;
+        if (deviceTwins['Screen']) {
+            for (const screenTwinId of deviceTwins['Screen']) {
+                const screenTwin = await phyHub.getCachedTwins(screenTwinId);
+                const { id: instanceId } = screenTwin;
+                if (instanceId === twinId && !this.hasMessageBeenDelivered(messageId, instanceId)) {
+                    this.io.to(instanceId).emit('twinUpdated', payload, callback);
+                    this.trackMessageDelivery(messageId, instanceId);
+                    screenEmitCount++;
+                    emissionCount++;
+                    logger.info(`handleTwinUpdated(): Emitted to Screen twin ${instanceId}`);
+                }
+            }
+            if (screenEmitCount === 0) {
+                logger.info(`handleTwinUpdated(): No Screen twins matched twin ${twinId} (out of ${deviceTwins['Screen'].length} Screen twins)`);
+            }
+        }
+        let peripheralEmitCount = 0;
+        if (deviceTwins['Peripheral']) {
+            for (const peripheralTwinId of deviceTwins['Peripheral']) {
+                const peripheralTwin = await phyHub.getCachedTwins(peripheralTwinId);
+                const { instanceId } = peripheralTwin.properties.desired;
+                if (instanceId && deviceTwins['Edge'].includes(instanceId) && !this.hasMessageBeenDelivered(messageId, instanceId)) {
+                    this.io.to(instanceId).emit('twinUpdated', payload);
+                    this.trackMessageDelivery(messageId, instanceId);
+                    peripheralEmitCount++;
+                    emissionCount++;
+                    logger.info(`handleTwinUpdated(): Emitted to Edge instance ${instanceId} for Peripheral twin ${peripheralTwinId}`);
+                }
+            }
+            if (peripheralEmitCount === 0) {
+                logger.info(`handleTwinUpdated(): No Peripheral twins matched criteria for twin ${twinId} (out of ${deviceTwins['Peripheral'].length} Peripheral twins)`);
+            }
+        }
+        if (emissionCount === 0) {
+            logger.warn(`handleTwinUpdated(): Twin update for ${twinId} was not emitted to any recipient!`);
+        }
+        else {
+            logger.info(`handleTwinUpdated(): Twin update for ${twinId} was emitted to ${emissionCount} recipients`);
+        }
+        if (callback)
+            callback({ status: 'success' });
+        return { status: 'success' };
+    }
+}
+exports.EdgeHubServer = EdgeHubServer;
+async function startEdgeHub() {
+    const server = EdgeHubServer.getInstance();
+    await server.start();
+}
+//# sourceMappingURL=edge-hub.js.map