@phystack/hub-client 4.4.52 → 4.4.54

package/dist/index.js

@@ -1,43 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.connectPhyClient = exports.PhyHubClient = void 0;
+exports.createTwinMessaging = exports.WebRTCManager = exports.TwinMessageResultStatus = exports.connectPhyClient = exports.PhyHubClient = void 0;
 const twin_types_1 = require("./types/twin.types");
+Object.defineProperty(exports, "TwinMessageResultStatus", { enumerable: true, get: function () { return twin_types_1.TwinMessageResultStatus; } });
 const phyhub_connection_service_1 = require("./services/phyhub-connection.service");
+const phyhub_direct_connection_service_1 = require("./services/phyhub-direct-connection.service");
 const signals_service_1 = require("./services/signals.service");
 const signal_types_1 = require("./types/signal.types");
-const datachannel_1 = require("./services/webrtc/datachannel");
-const mediastream_1 = require("./services/webrtc/mediastream");
-(async function initializeWebRTCGlobals() {
-    if (typeof window !== 'undefined')
-        return;
-    try {
-        const wrtc = require('@roamhq/wrtc');
-        if (typeof global.MediaStream === 'undefined' && wrtc.MediaStream) {
-            global.MediaStream = wrtc.MediaStream;
-            console.log('Global MediaStream initialized');
-        }
-        if (typeof global.RTCPeerConnection === 'undefined' && wrtc.RTCPeerConnection) {
-            global.RTCPeerConnection = wrtc.RTCPeerConnection;
-            console.log('Global RTCPeerConnection initialized');
-        }
-        if (typeof global.RTCSessionDescription === 'undefined' && wrtc.RTCSessionDescription) {
-            global.RTCSessionDescription = wrtc.RTCSessionDescription;
-            console.log('Global RTCSessionDescription initialized');
-        }
-        if (typeof global.RTCIceCandidate === 'undefined' && wrtc.RTCIceCandidate) {
-            global.RTCIceCandidate = wrtc.RTCIceCandidate;
-            console.log('Global RTCIceCandidate initialized');
-        }
-        if (typeof global.RTCVideoSource === 'undefined' && wrtc.nonstandard.RTCVideoSource) {
-            global.RTCVideoSource = wrtc.nonstandard.RTCVideoSource;
-            console.log('Global RTCVideoSource initialized');
-        }
-        console.log('WebRTC globals successfully initialized');
-    }
-    catch (error) {
-        console.error('Failed to initialize WebRTC globals:', error);
-    }
-})().catch(err => console.error('Error in WebRTC globals initialization:', err));
+const webrtc_1 = require("./services/webrtc");
+const twin_registry_1 = require("./twin-registry");
+const twin_messaging_1 = require("./twin-messaging");
 class PhyHubClient {
     constructor(params = {}) {
         this.instanceId = undefined;
@@ -50,8 +22,9 @@ class PhyHubClient {
         this.subscribedTwins = new Set();
         this.twinMessageListeners = {};
         this.instances = new Map();
-        this.peripheralInstances = new Map();
         this.twinUpdateListeners = {};
+        this.twinInstancesRegistry = null;
+        this.webrtcManager = null;
         this.EVENTS = {
             PING: 'ping',
             PONG: 'pong',
@@ -109,51 +82,21 @@ class PhyHubClient {
             this.signals = new signals_service_1.SignalsService(this, initSignalsPayload);
             return this.signals;
         };
-        this.getDataChannel = async (targetTwinId) => {
-            const options = {
-                targetTwinId,
-                sendTwinMessage: this.sendTwinMessage.bind(this),
-                subscribeTwin: this.subscribeTwin.bind(this),
-                onTwinMessage: this.onTwinMessage.bind(this),
-                offTwinMessage: this.offTwinMessage.bind(this),
-                useStun: true,
-                isInitiator: true,
-                channelPrefix: 'channel',
-                mediaOptions: { isMediaConnection: false },
-            };
-            const result = (await (0, datachannel_1.createWebRTCDataChannelConnection)(options));
-            return result.dataChannel;
+        this.getDataChannel = async (targetTwinId, channelName) => {
+            const manager = await this.getWebRTCManager();
+            return manager.createDataChannel(targetTwinId, channelName);
         };
-        this.onDataChannel = async (sourceTwinId, callback) => {
-            const options = {
-                targetTwinId: sourceTwinId,
-                sendTwinMessage: this.sendTwinMessage.bind(this),
-                subscribeTwin: this.subscribeTwin.bind(this),
-                onTwinMessage: this.onTwinMessage.bind(this),
-                offTwinMessage: this.offTwinMessage.bind(this),
-                useStun: true,
-                isInitiator: false,
-                channelPrefix: 'channel',
-                mediaOptions: { isMediaConnection: false },
-            };
-            const result = (await (0, datachannel_1.createWebRTCDataChannelConnection)(options));
-            callback(result.dataChannel);
+        this.onDataChannel = async (sourceTwinId, callback, channelName) => {
+            const manager = await this.getWebRTCManager();
+            const channel = await manager.acceptDataChannel(sourceTwinId, channelName);
+            callback(channel);
         };
-        this.onMediaStream = async (sourceTwinId, callback) => {
-            const options = {
-                targetTwinId: sourceTwinId,
-                sendTwinMessage: this.sendTwinMessage.bind(this),
-                subscribeTwin: this.subscribeTwin.bind(this),
-                onTwinMessage: this.onTwinMessage.bind(this),
-                offTwinMessage: this.offTwinMessage.bind(this),
-                isInitiator: false,
-                channelPrefix: 'media',
-                mediaOptions: {
-                    isMediaConnection: true,
-                },
-            };
-            const result = await (0, mediastream_1.createWebRTCMediaStreamConnection)(options);
-            callback(result.mediaStream);
+        this.onMediaStream = async (sourceTwinId, callback, options) => {
+            var _a;
+            const manager = await this.getWebRTCManager();
+            const channelName = (_a = options === null || options === void 0 ? void 0 : options.channelName) !== null && _a !== void 0 ? _a : 'default';
+            const stream = await manager.acceptMediaStream(sourceTwinId, options, channelName);
+            callback(stream);
         };
         this.instanceId = params.instanceId;
         if (!this.instanceId) {
@@ -202,6 +145,9 @@ class PhyHubClient {
             this.setupSocketListeners((value) => value, (reason) => {
                 throw reason;
             });
+            if (phyhub_direct_connection_service_1.PhyHubDirectConnection.isEnabled()) {
+                await this.initializeDirectConnectionTwin();
+            }
             return this;
         }
         catch (err) {
@@ -247,23 +193,44 @@ class PhyHubClient {
         this.socket.on(this.EVENTS.DISCONNECT, () => {
             this.socketConnected = false;
         });
-        this.socket.on(this.EVENTS.TWIN_MESSAGE, (payload) => {
-            if (payload.twinId && payload.data) {
-                const listeners = this.twinMessageListeners[payload.twinId];
-                if (listeners) {
-                    listeners.forEach(callback => {
+        this.socket.on(this.EVENTS.TWIN_MESSAGE, (payload, callback) => {
+            var _a;
+            console.log('[TWIN_MESSAGE] Received:', {
+                twinId: payload.twinId,
+                sourceTwinId: payload.sourceTwinId,
+                dataType: (_a = payload.data) === null || _a === void 0 ? void 0 : _a.type,
+            });
+            let result = null;
+            if (payload.data) {
+                const sourceTwinId = payload.sourceTwinId;
+                const targetTwinId = payload.twinId;
+                let listeners = sourceTwinId ? this.twinMessageListeners[sourceTwinId] : undefined;
+                if (!listeners && targetTwinId) {
+                    listeners = this.twinMessageListeners[targetTwinId];
+                }
+                if (listeners === null || listeners === void 0 ? void 0 : listeners.size) {
+                    console.log(`[TWIN_MESSAGE] Executing ${listeners.size} listeners`);
+                    listeners.forEach(listener => {
                         try {
-                            callback(payload);
+                            listener(payload);
+                            result = { status: twin_types_1.TwinMessageResultStatus.Success, message: 'Action completed' };
                         }
                         catch (error) {
-                            console.error(`Error in twin message listener for ${payload.twinId}:`, error);
+                            console.error(`[TWIN_MESSAGE] Error in listener:`, error);
+                            result = { status: twin_types_1.TwinMessageResultStatus.Error, message: (error === null || error === void 0 ? void 0 : error.message) || 'An error occurred' };
                         }
                     });
                 }
                 else {
+                    console.log(`[TWIN_MESSAGE] No listeners found for source=${sourceTwinId} or target=${targetTwinId}`);
+                    result = { status: twin_types_1.TwinMessageResultStatus.Warning, message: `No listeners found` };
+                }
+                if (callback) {
+                    callback(result);
                 }
             }
             else {
+                console.log('[TWIN_MESSAGE] Invalid payload (no data):', payload);
             }
         });
         this.socket.on('twinUpdated', (payload) => {
@@ -297,6 +264,7 @@ class PhyHubClient {
         if (!PhyHubClient.instance) {
             PhyHubClient.instance = new PhyHubClient(params);
             await PhyHubClient.instance.initializeConnection();
+            PhyHubClient.instance.twinInstancesRegistry = new twin_registry_1.TwinRegistry(PhyHubClient.instance);
             console.info(`connect(): Connection to phyhub initialized`);
         }
         return PhyHubClient.instance;
@@ -352,26 +320,43 @@ class PhyHubClient {
             });
         });
     }
-    async getMediaStream(targetTwinId) {
-        const options = {
-            targetTwinId,
-            sendTwinMessage: this.sendTwinMessage.bind(this),
-            subscribeTwin: this.subscribeTwin.bind(this),
-            onTwinMessage: this.onTwinMessage.bind(this),
-            offTwinMessage: this.offTwinMessage.bind(this),
-            isInitiator: true,
-            channelPrefix: 'media',
-            mediaOptions: {
-                isMediaConnection: true,
-                mediaDirection: 'recvonly',
-            },
-        };
-        const result = await (0, mediastream_1.createWebRTCMediaStreamConnection)(options);
+    async getMediaStream(targetTwinId, options) {
+        var _a;
+        const manager = await this.getWebRTCManager();
+        const channelName = (_a = options === null || options === void 0 ? void 0 : options.channelName) !== null && _a !== void 0 ? _a : 'default';
+        const stream = await manager.createMediaStream(targetTwinId, options, channelName);
         return {
-            stream: result.mediaStream,
-            close: result.close,
+            stream,
+            close: () => stream.close(),
         };
     }
+    async getWebRTCManager(options) {
+        if (!this.webrtcManager) {
+            await this.assureSocketConnection();
+            const twinMessaging = {
+                sendMessage: async (targetTwinId, data) => {
+                    await this.sendTwinMessage(targetTwinId, data);
+                },
+                subscribe: async (twinId) => {
+                    await this.subscribeTwin(twinId);
+                },
+                onMessage: (twinId, callback) => {
+                    this.onTwinMessage(twinId, callback);
+                },
+                offMessage: (twinId, callback) => {
+                    this.offTwinMessage(twinId, callback);
+                },
+                getOwnTwinId: () => {
+                    if (!this.instanceId) {
+                        throw new Error('Instance ID not set');
+                    }
+                    return this.instanceId;
+                },
+            };
+            this.webrtcManager = new webrtc_1.WebRTCManager(twinMessaging, options);
+        }
+        return this.webrtcManager;
+    }
     async getInstance() {
         if (!this.instanceId) {
             throw new Error('Instance ID not set');
@@ -382,40 +367,12 @@ class PhyHubClient {
         await this.assureSocketConnection();
         let instance;
         let instanceTwin = await this.getTwinById(this.instanceId);
-        const edgeInstanceTypePrefix = 'edgeInstance';
-        const edgeTwinEmit = (type, payload) => {
-            const { id: twinId } = instanceTwin;
-            const edgeTwinMessagePayload = {
-                type: `${edgeInstanceTypePrefix}:${type}`,
-                sourceTwinId: twinId,
-                sourceDeviceId: instanceTwin.deviceId,
-                data: payload,
-            };
-            this.sendTwinMessage(twinId, edgeTwinMessagePayload);
-        };
-        const edgeTwinOn = (type, callback) => {
-            const { id: twinId } = instanceTwin;
-            const onEdgeTwinMessage = (payload) => {
-                var _a, _b;
-                const messageType = ((_a = payload.data) === null || _a === void 0 ? void 0 : _a.type) || payload.type;
-                if (messageType === `${edgeInstanceTypePrefix}:${type}`) {
-                    callback(((_b = payload.data) === null || _b === void 0 ? void 0 : _b.data) || payload.data);
-                }
-                else {
-                }
-            };
-            this.onTwinMessage(twinId, onEdgeTwinMessage);
-        };
-        const edgeTwinTo = (targetTwinId) => ({
-            emit: (type, payload) => {
-                const edgeTwinMessagePayload = {
-                    type: `${edgeInstanceTypePrefix}:${type}`,
-                    sourceTwinId: instanceTwin.id,
-                    sourceDeviceId: instanceTwin.deviceId,
-                    data: payload,
-                };
-                this.sendTwinMessage(targetTwinId, edgeTwinMessagePayload);
-            },
+        const messaging = (0, twin_messaging_1.createTwinMessaging)({
+            sendEvent: (targetTwinId, payload) => this.sendEvent(targetTwinId, payload),
+            onTwinMessage: (twinId, callback) => this.onTwinMessage(twinId, callback),
+            twinId: instanceTwin.id,
+            deviceId: instanceTwin.deviceId,
+            typePrefix: 'edgeInstance',
         });
         const getPeripheralTwins = async () => {
             const payload = {
@@ -464,23 +421,23 @@ class PhyHubClient {
                 });
             });
         };
-        const getDataChannel = async () => {
-            return await this.getDataChannel(instanceTwin.id);
+        const getDataChannel = async (channelName) => {
+            return await this.getDataChannel(instanceTwin.id, channelName);
         };
-        const onDataChannel = async (callback) => {
-            return await this.onDataChannel(instanceTwin.id, callback);
+        const onDataChannel = async (callback, channelName) => {
+            return await this.onDataChannel(instanceTwin.id, callback, channelName);
         };
-        const getMediaStream = async () => {
+        const getMediaStream = async (channelName) => {
             if (!instance) {
                 throw new Error('Instance not initialized');
             }
-            return await this.getMediaStream(instance.id);
+            return await this.getMediaStream(instance.id, { channelName });
         };
-        const onMediaStream = async (callback) => {
+        const onMediaStream = async (callback, channelName) => {
             if (!instance) {
                 throw new Error('Instance not initialized');
             }
-            await this.onMediaStream(instance.id, callback);
+            await this.onMediaStream(instance.id, callback, { channelName });
         };
         const updateReported = async (properties) => {
             const newReported = {
@@ -492,9 +449,9 @@ class PhyHubClient {
         };
         instance = {
             ...instanceTwin,
-            emit: edgeTwinEmit,
-            on: edgeTwinOn,
-            to: edgeTwinTo,
+            emit: messaging.emit,
+            on: messaging.on,
+            to: messaging.to,
             createPeripheralTwin,
             updateReported,
             getPeripheralTwins,
@@ -513,211 +470,10 @@ class PhyHubClient {
         return this.getInstance();
     }
     async getPeripheralInstance(peripheralTwinId) {
-        if (this.peripheralInstances.has(peripheralTwinId)) {
-            return this.peripheralInstances.get(peripheralTwinId);
+        if (!this.twinInstancesRegistry) {
+            throw new Error('PhyHubClient instance is not initialized yet');
         }
-        let peripheralInstance;
-        const edgeInstance = await this.getInstance();
-        if (!edgeInstance) {
-            console.error('Edge instance not found');
-            throw new Error('Edge instance not found');
-        }
-        const peripheralTwin = await this.getTwinById(peripheralTwinId);
-        if (!peripheralTwin) {
-            console.error(`Peripheral twin with id ${peripheralTwinId} not found`);
-            throw new Error(`Peripheral twin with id ${peripheralTwinId} not found`);
-        }
-        if (peripheralTwin.type !== twin_types_1.TwinTypeEnum.Peripheral) {
-            throw new Error(`Twin ${peripheralTwinId} is not a peripheral twin`);
-        }
-        await this.subscribeTwin(peripheralTwinId);
-        const instanceTypePrefix = 'peripheralInstance';
-        const peripheralTwinEmit = (type, payload) => {
-            const messagePayload = {
-                type: `${instanceTypePrefix}:${peripheralTwin.id}:${type}`,
-                sourceTwinId: peripheralTwin.id,
-                sourceDeviceId: edgeInstance.deviceId,
-                data: payload,
-            };
-            this.sendTwinMessage(peripheralTwin.id, messagePayload);
-        };
-        const peripheralTwinOn = (type, callback) => {
-            console.log(`Setting up listener for peripheral ${peripheralTwinId} event: ${type}`);
-            const onMessage = (payload) => {
-                var _a, _b;
-                const messageType = ((_a = payload.data) === null || _a === void 0 ? void 0 : _a.type) || payload.type;
-                if (messageType === `${instanceTypePrefix}:${peripheralTwin.id}:${type}`) {
-                    callback(((_b = payload.data) === null || _b === void 0 ? void 0 : _b.data) || payload.data);
-                }
-                else {
-                }
-            };
-            this.onTwinMessage(peripheralTwin.id, onMessage);
-        };
-        const peripheralTwinTo = (targetTwinId) => ({
-            emit: (type, payload) => {
-                const messagePayload = {
-                    type: `${instanceTypePrefix}:${peripheralTwin.id}:${type}`,
-                    sourceTwinId: edgeInstance.id,
-                    sourceDeviceId: edgeInstance.deviceId,
-                    data: payload,
-                };
-                this.sendTwinMessage(targetTwinId, messagePayload);
-            },
-        });
-        const getDataChannel = async () => {
-            return await this.getDataChannel(peripheralTwin.id);
-        };
-        const onDataChannel = async (callback) => {
-            return await this.onDataChannel(peripheralTwin.id, callback);
-        };
-        const getMediaStream = async () => {
-            if (!peripheralInstance) {
-                throw new Error('Peripheral instance not initialized');
-            }
-            return await this.getMediaStream(peripheralInstance.id);
-        };
-        const onMediaStream = async (callback) => {
-            if (!peripheralInstance) {
-                throw new Error('Peripheral instance not initialized');
-            }
-            await this.onMediaStream(peripheralInstance.id, callback);
-        };
-        const updateReported = async (properties) => {
-            const newReported = {
-                ...properties,
-            };
-            const result = await this.updateReportedProperties(peripheralTwin.id, newReported);
-            Object.assign(peripheralInstance, result);
-            return result;
-        };
-        const onUpdateReported = (callback) => {
-            let previousProperties = undefined;
-            console.log(`[onUpdateReported] Registering handler for all reported properties`);
-            this.onTwinUpdate(peripheralTwin.id, (twin) => {
-                console.log(`[onUpdateReported] Twin update received for ${peripheralTwin.id}`);
-                if (twin.id !== peripheralTwin.id) {
-                    console.log(`[onUpdateReported] Twin ID mismatch: ${twin.id} !== ${peripheralTwin.id}`);
-                    return;
-                }
-                const reported = twin.properties.reported;
-                if (reported) {
-                    if (previousProperties === undefined) {
-                        console.log(`[onUpdateReported] First update - calling callback`);
-                        previousProperties = JSON.parse(JSON.stringify(reported));
-                        callback(reported);
-                        return;
-                    }
-                    const currentPropertiesStr = JSON.stringify(reported);
-                    const previousPropertiesStr = JSON.stringify(previousProperties);
-                    console.log(`[onUpdateReported] Current (end): ...${currentPropertiesStr.substring(currentPropertiesStr.length - 100)}`);
-                    console.log(`[onUpdateReported] Previous (end): ...${previousPropertiesStr.substring(previousPropertiesStr.length - 100)}`);
-                    if (currentPropertiesStr.length !== previousPropertiesStr.length) {
-                        console.log(`[onUpdateReported] String length changed: ${currentPropertiesStr.length} vs ${previousPropertiesStr.length}`);
-                    }
-                    const hasChanged = currentPropertiesStr !== previousPropertiesStr;
-                    console.log(`[onUpdateReported] Properties comparison:`, hasChanged ? 'CHANGED' : 'UNCHANGED');
-                    if (hasChanged) {
-                        previousProperties = JSON.parse(currentPropertiesStr);
-                        console.log(`[onUpdateReported] Calling callback with updated reported properties`);
-                        callback(reported);
-                    }
-                    else {
-                        console.log(`[onUpdateReported] No change detected in properties`);
-                    }
-                }
-                else {
-                    console.log(`[onUpdateReported] No reported properties found`);
-                }
-            });
-        };
-        const onUpdateDesired = (callback) => {
-            let previousProperties = undefined;
-            console.log(`[onUpdateDesired] Registering handler for all desired properties`);
-            this.onTwinUpdate(peripheralTwin.id, (twin) => {
-                console.log(`[onUpdateDesired] Twin update received for ${peripheralTwin.id}`);
-                if (twin.id !== peripheralTwin.id) {
-                    console.log(`[onUpdateDesired] Twin ID mismatch: ${twin.id} !== ${peripheralTwin.id}`);
-                    return;
-                }
-                const desired = twin.properties.desired;
-                if (desired) {
-                    if (previousProperties === undefined) {
-                        console.log(`[onUpdateDesired] First update - calling callback`);
-                        previousProperties = JSON.parse(JSON.stringify(desired));
-                        callback(desired);
-                        return;
-                    }
-                    const currentPropertiesStr = JSON.stringify(desired);
-                    const previousPropertiesStr = JSON.stringify(previousProperties);
-                    console.log(`[onUpdateDesired] Current (end): ...${currentPropertiesStr.substring(currentPropertiesStr.length - 100)}`);
-                    console.log(`[onUpdateDesired] Previous (end): ...${previousPropertiesStr.substring(previousPropertiesStr.length - 100)}`);
-                    if (currentPropertiesStr.length !== previousPropertiesStr.length) {
-                        console.log(`[onUpdateDesired] String length changed: ${currentPropertiesStr.length} vs ${previousPropertiesStr.length}`);
-                    }
-                    const hasChanged = currentPropertiesStr !== previousPropertiesStr;
-                    console.log(`[onUpdateDesired] Properties comparison:`, hasChanged ? 'CHANGED' : 'UNCHANGED');
-                    if (hasChanged) {
-                        previousProperties = JSON.parse(currentPropertiesStr);
-                        console.log(`[onUpdateDesired] Calling callback with updated desired properties`);
-                        callback(desired);
-                    }
-                    else {
-                        console.log(`[onUpdateDesired] No change detected in properties`);
-                    }
-                }
-                else {
-                    console.log(`[onUpdateDesired] No desired properties found`);
-                }
-            });
-        };
-        const remove = async () => {
-            const payload = {
-                data: { twinId: peripheralTwin.id },
-            };
-            return new Promise((resolve, reject) => {
-                var _a;
-                this.emit('deletePeripheralTwin', payload, (response) => {
-                    const { twin } = response;
-                    resolve(twin);
-                });
-                (_a = this.socket) === null || _a === void 0 ? void 0 : _a.on('error', (error) => {
-                    reject(error);
-                });
-            });
-        };
-        const updateDesired = async (properties) => {
-            const payload = {
-                twinId: peripheralTwin.id,
-                data: properties,
-            };
-            return new Promise((resolve, reject) => {
-                var _a;
-                this.emit('updatePeripheralTwinDesired', payload, (response) => {
-                    const { twin } = response;
-                    resolve(twin || {});
-                });
-                (_a = this.socket) === null || _a === void 0 ? void 0 : _a.on('error', (error) => {
-                    reject(error);
-                });
-            });
-        };
-        peripheralInstance = {
-            ...peripheralTwin,
-            emit: peripheralTwinEmit,
-            on: peripheralTwinOn,
-            to: peripheralTwinTo,
-            updateReported,
-            updateDesired,
-            onUpdateReported,
-            onUpdateDesired,
-            remove,
-            getDataChannel,
-            onDataChannel,
-            getMediaStream,
-            onMediaStream,
-        };
-        this.peripheralInstances.set(peripheralTwinId, peripheralInstance);
+        const peripheralInstance = await this.twinInstancesRegistry.getPeripheralInstance(peripheralTwinId);
         return peripheralInstance;
     }
     getGridApp() {
@@ -732,7 +488,7 @@ class PhyHubClient {
                     break;
                 currentWindow = currentWindow.parent;
             }
-            catch (e) {
+            catch (_a) {
                 break;
             }
         }
@@ -799,10 +555,17 @@ class PhyHubClient {
             console.error('emit(): Socket not created');
             return;
         }
-        const event = this.instanceId;
         const callback = typeof args[args.length - 1] === 'function' ? args.pop() : undefined;
-        const payload = { method, ...args[0] };
-        const emitArgs = [event, payload];
+        let emitArgs;
+        if (phyhub_direct_connection_service_1.PhyHubDirectConnection.isEnabled()) {
+            const payload = args[0] || {};
+            emitArgs = [method, payload];
+        }
+        else {
+            const event = this.instanceId;
+            const payload = { method, ...args[0] };
+            emitArgs = [event, payload];
+        }
         if (callback) {
             emitArgs.push(callback);
         }
@@ -854,15 +617,37 @@ class PhyHubClient {
         }
         return result;
     }
-    async sendTwinMessage(targetTwinId, data, callback) {
+    sendEvent(targetTwinId, data) {
+        var _a;
+        const instanceId = this.instanceId;
+        if (!instanceId) {
+            console.error('[sendEvent] Instance ID not set, cannot send event');
+            return;
+        }
+        const cachedInstance = this.instances.get(instanceId);
+        const deviceId = (cachedInstance === null || cachedInstance === void 0 ? void 0 : cachedInstance.deviceId) || ((_a = this.lastDeviceStatusResponse) === null || _a === void 0 ? void 0 : _a.deviceId);
+        if (!deviceId) {
+            console.error('[sendEvent] Device ID not available, cannot send event');
+            return;
+        }
+        const payload = {
+            twinId: targetTwinId,
+            sourceTwinId: instanceId,
+            sourceDeviceId: deviceId,
+            data,
+        };
+        this.emit(this.EVENTS.TWIN_MESSAGE, payload);
+    }
+    async request(targetTwinId, data, callback) {
+        console.log('[request] Sending to:', targetTwinId, 'data type:', (data === null || data === void 0 ? void 0 : data.type) || 'unknown');
         const edgeInstance = await this.getInstance();
         if (!edgeInstance) {
-            console.error('sendTwinMessage failed: Edge instance not found');
+            console.error('[request] Edge instance not found');
             throw new Error('Edge instance not found');
         }
         const { id: edgeTwinId, deviceId } = edgeInstance;
         if (!deviceId) {
-            console.error('sendTwinMessage failed: Device ID not available');
+            console.error('[request] Device ID not available');
             throw new Error('Device ID not available - ensure device is connected');
         }
         const payload = {
@@ -875,19 +660,72 @@ class PhyHubClient {
             this.emit(this.EVENTS.TWIN_MESSAGE, payload, (response) => {
                 callback(response);
             });
+            return;
         }
-        else {
-            return new Promise((resolve, reject) => {
+        return new Promise((resolve, reject) => {
+            var _a;
+            const ACTION_TIMEOUT = 10 * 1000;
+            const timeoutId = setTimeout(() => {
                 var _a;
-                this.emit(this.EVENTS.TWIN_MESSAGE, payload, (response) => {
-                    resolve(response);
+                if (this.socket) {
+                    (_a = this.socket) === null || _a === void 0 ? void 0 : _a.off(payload.data.type);
+                }
+                reject({
+                    status: twin_types_1.TwinMessageResultStatus.Error,
+                    message: `Request timed out after ${ACTION_TIMEOUT}ms`
                 });
-                (_a = this.socket) === null || _a === void 0 ? void 0 : _a.on('error', (error) => {
-                    console.error('sendTwinMessage socket error:', error);
-                    reject(error);
+            }, ACTION_TIMEOUT);
+            if (this.socket) {
+                this.socket.on(payload.data.type, (response) => {
+                    var _a;
+                    if (response && response.status !== twin_types_1.TwinMessageResultStatus.Warning) {
+                        clearTimeout(timeoutId);
+                        (_a = this.socket) === null || _a === void 0 ? void 0 : _a.off(payload.data.type);
+                        resolve(response);
+                    }
                 });
+            }
+            this.emit(this.EVENTS.TWIN_MESSAGE, payload, (response) => {
+                var _a;
+                clearTimeout(timeoutId);
+                if (this.socket) {
+                    (_a = this.socket) === null || _a === void 0 ? void 0 : _a.off(payload.data.type);
+                }
+                resolve(response);
+            });
+            (_a = this.socket) === null || _a === void 0 ? void 0 : _a.on('error', (error) => {
+                clearTimeout(timeoutId);
+                console.error('[request] Socket error:', error);
+                reject(error);
+            });
+        });
+    }
+    async sendTwinMessage(targetTwinId, data, callback) {
+        console.log('[sendTwinMessage] Sending to:', targetTwinId, 'data type:', (data === null || data === void 0 ? void 0 : data.type) || 'unknown');
+        const edgeInstance = await this.getInstance();
+        if (!edgeInstance) {
+            console.error('sendTwinMessage failed: Edge instance not found');
+            throw new Error('Edge instance not found');
+        }
+        const { id: edgeTwinId, deviceId } = edgeInstance;
+        if (!deviceId) {
+            console.error('sendTwinMessage failed: Device ID not available');
+            throw new Error('Device ID not available - ensure device is connected');
+        }
+        const payload = {
+            twinId: targetTwinId,
+            sourceTwinId: edgeTwinId,
+            sourceDeviceId: deviceId,
+            data,
+        };
+        if (callback) {
+            this.emit(this.EVENTS.TWIN_MESSAGE, payload, (response) => {
+                callback(response);
             });
         }
+        else {
+            this.emit(this.EVENTS.TWIN_MESSAGE, payload);
+        }
     }
     async onTwinMessage(targetTwinId, callback) {
         var _a;
@@ -964,12 +802,14 @@ class PhyHubClient {
         }
     }
     async getTwinById(twinId) {
+        console.log(`[getTwinById] Fetching twin: ${twinId}`);
         const payload = {
             data: { twinId },
         };
         return new Promise((resolve, reject) => {
             var _a;
             this.emit(this.EVENTS.GET_TWIN_BY_ID, payload, (response) => {
+                console.log(`[getTwinById] Response for ${twinId}:`, response);
                 const { twin } = response;
                 if (!twin) {
                     reject(new Error(`Twin with id ${twinId} not found`));
@@ -978,6 +818,7 @@ class PhyHubClient {
                 resolve(twin);
             });
             (_a = this.socket) === null || _a === void 0 ? void 0 : _a.on('error', (error) => {
+                console.error(`[getTwinById] Socket error for ${twinId}:`, error);
                 reject(error);
             });
         });
@@ -1002,6 +843,64 @@ class PhyHubClient {
             });
         });
     }
+    async initializeDirectConnectionTwin() {
+        console.log('[initializeDirectConnectionTwin] Waiting for authentication...');
+        await new Promise((resolve, reject) => {
+            var _a;
+            const timeout = setTimeout(() => {
+                reject(new Error('Timeout waiting for deviceAuthenticated'));
+            }, 10000);
+            (_a = this.socket) === null || _a === void 0 ? void 0 : _a.once('deviceAuthenticated', (data) => {
+                clearTimeout(timeout);
+                console.log('[initializeDirectConnectionTwin] Authenticated:', data);
+                resolve();
+            });
+        });
+        console.log('[initializeDirectConnectionTwin] Calling connectDevice...');
+        return new Promise((resolve, reject) => {
+            var _a;
+            const timeout = setTimeout(() => {
+                reject(new Error('Timeout waiting for connectDevice response'));
+            }, 10000);
+            (_a = this.socket) === null || _a === void 0 ? void 0 : _a.emit('connectDevice', (response) => {
+                var _a;
+                clearTimeout(timeout);
+                console.log('[initializeDirectConnectionTwin] connectDevice response:', JSON.stringify(response, null, 2));
+                if ((response === null || response === void 0 ? void 0 : response.status) === 'success' && ((_a = response === null || response === void 0 ? void 0 : response.twins) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+                    const deviceTwin = response.twins.find((t) => t.type === 'Device');
+                    if (deviceTwin) {
+                        const actualTwinId = deviceTwin.id || deviceTwin._id;
+                        console.log(`[initializeDirectConnectionTwin] Got device twin. DeviceId: ${deviceTwin.deviceId}, TwinId: ${actualTwinId}`);
+                        this.instanceId = actualTwinId;
+                        resolve();
+                    }
+                    else {
+                        console.error('[initializeDirectConnectionTwin] No device twin found in twins array');
+                        reject(new Error('No device twin found for this device'));
+                    }
+                }
+                else if ((response === null || response === void 0 ? void 0 : response.status) === 'error') {
+                    const errorMessage = (response === null || response === void 0 ? void 0 : response.message) || 'Unknown error';
+                    console.error('[initializeDirectConnectionTwin] connectDevice failed:', errorMessage);
+                    if (errorMessage.includes('Failed to find device twin')) {
+                        console.error('\n=== DEVICE TWIN NOT FOUND ===');
+                        console.error('This device exists in the legacy database but has not been');
+                        console.error('properly migrated to PhyHub. The device twins need to be created.');
+                        console.error('');
+                        console.error('To fix this:');
+                        console.error('1. Reset isMigratedToPhyhub flag in legacy DB, OR');
+                        console.error('2. Use a different device that has been properly migrated');
+                        console.error('==============================\n');
+                    }
+                    reject(new Error(errorMessage));
+                }
+                else {
+                    console.error('[initializeDirectConnectionTwin] Unexpected response:', response);
+                    reject(new Error('Failed to connect device'));
+                }
+            });
+        });
+    }
 }
 exports.PhyHubClient = PhyHubClient;
 PhyHubClient.instance = null;
@@ -1010,4 +909,8 @@ exports.connectPhyClient = connectPhyClient;
 exports.default = {
     connectPhyClient: exports.connectPhyClient,
 };
+var webrtc_2 = require("./services/webrtc");
+Object.defineProperty(exports, "WebRTCManager", { enumerable: true, get: function () { return webrtc_2.WebRTCManager; } });
+var twin_messaging_2 = require("./twin-messaging");
+Object.defineProperty(exports, "createTwinMessaging", { enumerable: true, get: function () { return twin_messaging_2.createTwinMessaging; } });
 //# sourceMappingURL=index.js.map