@phystack/hub-client 4.4.53 → 4.4.54

package/dist/index.js

@@ -1,59 +1,15 @@
 "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 __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 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");
+const webrtc_1 = require("./services/webrtc");
 const twin_registry_1 = require("./twin-registry");
-__exportStar(require("./types"), exports);
-(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 twin_messaging_1 = require("./twin-messaging");
 class PhyHubClient {
     constructor(params = {}) {
         this.instanceId = undefined;
@@ -68,6 +24,7 @@ class PhyHubClient {
         this.instances = new Map();
         this.twinUpdateListeners = {};
         this.twinInstancesRegistry = null;
+        this.webrtcManager = null;
         this.EVENTS = {
             PING: 'ping',
             PONG: 'pong',
@@ -125,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) {
@@ -218,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) {
@@ -264,27 +194,43 @@ class PhyHubClient {
             this.socketConnected = false;
         });
         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.twinId && payload.data) {
-                const listeners = this.twinMessageListeners[payload.twinId];
+            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 {
                             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 {
-                    result = { status: twin_types_1.TwinMessageResultStatus.Warning, message: `No listeners found for twin ${payload.twinId} on this socket` };
+                    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);
                 }
-                callback(result);
             }
             else {
+                console.log('[TWIN_MESSAGE] Invalid payload (no data):', payload);
             }
         });
         this.socket.on('twinUpdated', (payload) => {
@@ -374,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');
@@ -404,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 = {
@@ -486,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 = {
@@ -514,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,
@@ -553,7 +488,7 @@ class PhyHubClient {
                     break;
                 currentWindow = currentWindow.parent;
             }
-            catch (e) {
+            catch (_a) {
                 break;
             }
         }
@@ -620,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);
         }
@@ -675,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 = {
@@ -696,37 +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;
-                const twinMessageTimeout = 10 * 1000;
-                const twinMessageTimeoutId = setTimeout(() => {
+                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`
+                });
+            }, ACTION_TIMEOUT);
+            if (this.socket) {
+                this.socket.on(payload.data.type, (response) => {
                     var _a;
-                    if (this.socket) {
+                    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);
                     }
-                    reject({ status: twin_types_1.TwinMessageResultStatus.Error, message: `twinMessage failed to complete in specified time (${twinMessageTimeout} ms)` });
-                }, twinMessageTimeout);
+                });
+            }
+            this.emit(this.EVENTS.TWIN_MESSAGE, payload, (response) => {
+                var _a;
+                clearTimeout(timeoutId);
                 if (this.socket) {
-                    this.socket.on(payload.data.type, (response) => {
-                        var _a;
-                        if (response && response.status !== twin_types_1.TwinMessageResultStatus.Warning) {
-                            clearTimeout(twinMessageTimeoutId);
-                            (_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.off(payload.data.type);
                 }
-                this.emit(this.EVENTS.TWIN_MESSAGE, payload, (response) => {
-                    console.log('sendTwinMessage promise received response:', response);
-                });
-                (_a = this.socket) === null || _a === void 0 ? void 0 : _a.on('error', (error) => {
-                    console.error('sendTwinMessage socket error:', error);
-                    reject(error);
-                });
+                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;
@@ -803,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`));
@@ -817,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);
             });
         });
@@ -841,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;
@@ -849,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