agentic-qe 2.7.4 → 2.8.0

package/dist/edge/p2p/nat/TURNManager.d.ts

@@ -0,0 +1,158 @@
+/**
+ * TURN Manager for @ruvector/edge P2P
+ *
+ * Manages TURN server credentials, handles credential refresh, selects optimal
+ * TURN servers based on latency, and monitors server health.
+ *
+ * @module edge/p2p/nat/TURNManager
+ * @version 1.0.0
+ */
+import { ICEServer } from '../webrtc/types';
+import { TURNConfig, TURNServerSelection, TURNManagerConfig, NATEventType, NATEventHandler } from './types';
+/**
+ * TURN server health status
+ */
+interface TURNServerHealth {
+    /** Server configuration */
+    server: TURNConfig;
+    /** Whether server is healthy */
+    healthy: boolean;
+    /** Last measured latency in ms */
+    latencyMs: number;
+    /** Last health check timestamp */
+    lastCheckAt: number;
+    /** Consecutive failure count */
+    failureCount: number;
+    /** Last error message */
+    lastError?: string;
+}
+/**
+ * TURN Manager - Manages TURN server credentials and selection
+ *
+ * @example
+ * ```typescript
+ * const turnManager = new TURNManager({
+ *   servers: [
+ *     {
+ *       urls: 'turn:turn1.example.com:3478',
+ *       username: 'user',
+ *       credential: 'pass',
+ *       credentialType: 'password',
+ *     },
+ *   ],
+ *   credentialConfig: {
+ *     refreshUrl: 'https://api.example.com/turn/credentials',
+ *     refreshBeforeExpiry: 300000, // 5 minutes
+ *     maxRetries: 3,
+ *     retryDelay: 1000,
+ *   },
+ * });
+ *
+ * // Get optimal TURN server
+ * const selection = await turnManager.selectOptimalServer();
+ * console.log('Selected server:', selection.server.urls);
+ *
+ * // Get ICE servers for RTCPeerConnection
+ * const iceServers = turnManager.getICEServers();
+ * ```
+ */
+export declare class TURNManager {
+    private readonly config;
+    private serverHealth;
+    private credentialStates;
+    private eventHandlers;
+    private healthCheckInterval?;
+    private isDestroyed;
+    /**
+     * Create a new TURN Manager
+     *
+     * @param config - Manager configuration
+     */
+    constructor(config: TURNManagerConfig);
+    /**
+     * Select optimal TURN server based on latency
+     *
+     * @returns Promise resolving to server selection with alternatives
+     */
+    selectOptimalServer(): Promise<TURNServerSelection>;
+    /**
+     * Get ICE servers configuration for RTCPeerConnection
+     *
+     * @param includeUnhealthy - Include unhealthy servers (default: false)
+     * @returns Array of ICE server configurations
+     */
+    getICEServers(includeUnhealthy?: boolean): ICEServer[];
+    /**
+     * Get a specific server's current credentials
+     *
+     * @param serverUrl - Server URL to get credentials for
+     * @returns Server configuration with current credentials or null
+     */
+    getServerCredentials(serverUrl: string): TURNConfig | null;
+    /**
+     * Manually refresh credentials for a server
+     *
+     * @param serverUrl - Server URL to refresh credentials for
+     * @returns Promise resolving to refreshed credentials
+     */
+    refreshCredentials(serverUrl: string): Promise<TURNConfig>;
+    /**
+     * Add a new TURN server to the manager
+     *
+     * @param server - Server configuration to add
+     */
+    addServer(server: TURNConfig): void;
+    /**
+     * Remove a TURN server from the manager
+     *
+     * @param serverUrl - Server URL to remove
+     */
+    removeServer(serverUrl: string): void;
+    /**
+     * Get server health status
+     *
+     * @param serverUrl - Server URL to check
+     * @returns Health status or null if not found
+     */
+    getServerHealth(serverUrl: string): TURNServerHealth | null;
+    /**
+     * Get all server health statuses
+     *
+     * @returns Map of server URLs to health statuses
+     */
+    getAllServerHealth(): Map<string, TURNServerHealth>;
+    /**
+     * Force health check for all servers
+     */
+    checkAllServersHealth(): Promise<void>;
+    /**
+     * Register event handler
+     *
+     * @param type - Event type to handle
+     * @param handler - Event handler function
+     * @returns Unsubscribe function
+     */
+    on<T>(type: NATEventType, handler: NATEventHandler<T>): () => void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): TURNManagerConfig;
+    /**
+     * Destroy the manager and cleanup resources
+     */
+    destroy(): void;
+    private getServerUrl;
+    private getHealthyServers;
+    private testServerLatencies;
+    private measureLatency;
+    private testTurnConnectivity;
+    private checkServerHealth;
+    private startHealthMonitoring;
+    private scheduleCredentialRefresh;
+    private fetchNewCredentials;
+    private doCredentialFetch;
+    private delay;
+    private emitEvent;
+}
+export default TURNManager;
+//# sourceMappingURL=TURNManager.d.ts.map

package/dist/edge/p2p/nat/TURNManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TURNManager.d.ts","sourceRoot":"","sources":["../../../../src/edge/p2p/nat/TURNManager.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EACL,UAAU,EAGV,mBAAmB,EACnB,iBAAiB,EACjB,YAAY,EAEZ,eAAe,EAEhB,MAAM,SAAS,CAAC;AAEjB;;GAEG;AACH,UAAU,gBAAgB;IACxB,2BAA2B;IAC3B,MAAM,EAAE,UAAU,CAAC;IACnB,gCAAgC;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,kCAAkC;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,kCAAkC;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,gCAAgC;IAChC,YAAY,EAAE,MAAM,CAAC;IACrB,yBAAyB;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAgBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAoB;IAC3C,OAAO,CAAC,YAAY,CAA4C;IAChE,OAAO,CAAC,gBAAgB,CAA2C;IACnE,OAAO,CAAC,aAAa,CAAsD;IAC3E,OAAO,CAAC,mBAAmB,CAAC,CAAiC;IAC7D,OAAO,CAAC,WAAW,CAAkB;IAErC;;;;OAIG;gBACS,MAAM,EAAE,iBAAiB;IAqCrC;;;;OAIG;IACU,mBAAmB,IAAI,OAAO,CAAC,mBAAmB,CAAC;IAwBhE;;;;;OAKG;IACI,aAAa,CAAC,gBAAgB,GAAE,OAAe,GAAG,SAAS,EAAE;IAapE;;;;;OAKG;IACI,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI;IAKjE;;;;;OAKG;IACU,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAavE;;;;OAIG;IACI,SAAS,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IA0B1C;;;;OAIG;IACI,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAkB5C;;;;;OAKG;IACI,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI;IAIlE;;;;OAIG;IACI,kBAAkB,IAAI,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAI1D;;OAEG;IACU,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC;IAKnD;;;;;;OAMG;IACI,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI;IAQzE;;OAEG;IACI,SAAS,IAAI,iBAAiB;IAIrC;;OAEG;IACI,OAAO,IAAI,IAAI;IAyBtB,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,iBAAiB;YAUX,mBAAmB;YA2BnB,cAAc;YAWd,oBAAoB;YAwEpB,iBAAiB;IA4B/B,OAAO,CAAC,qBAAqB;IAU7B,OAAO,CAAC,yBAAyB;YA6BnB,mBAAmB;YA2EnB,iBAAiB;IA2C/B,OAAO,CAAC,KAAK;IAIb,OAAO,CAAC,SAAS;CAiBlB;AAED,eAAe,WAAW,CAAC"}

package/dist/edge/p2p/nat/TURNManager.js

@@ -0,0 +1,547 @@
+"use strict";
+/**
+ * TURN Manager for @ruvector/edge P2P
+ *
+ * Manages TURN server credentials, handles credential refresh, selects optimal
+ * TURN servers based on latency, and monitors server health.
+ *
+ * @module edge/p2p/nat/TURNManager
+ * @version 1.0.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TURNManager = void 0;
+const types_1 = require("./types");
+/**
+ * TURN Manager - Manages TURN server credentials and selection
+ *
+ * @example
+ * ```typescript
+ * const turnManager = new TURNManager({
+ *   servers: [
+ *     {
+ *       urls: 'turn:turn1.example.com:3478',
+ *       username: 'user',
+ *       credential: 'pass',
+ *       credentialType: 'password',
+ *     },
+ *   ],
+ *   credentialConfig: {
+ *     refreshUrl: 'https://api.example.com/turn/credentials',
+ *     refreshBeforeExpiry: 300000, // 5 minutes
+ *     maxRetries: 3,
+ *     retryDelay: 1000,
+ *   },
+ * });
+ *
+ * // Get optimal TURN server
+ * const selection = await turnManager.selectOptimalServer();
+ * console.log('Selected server:', selection.server.urls);
+ *
+ * // Get ICE servers for RTCPeerConnection
+ * const iceServers = turnManager.getICEServers();
+ * ```
+ */
+class TURNManager {
+    /**
+     * Create a new TURN Manager
+     *
+     * @param config - Manager configuration
+     */
+    constructor(config) {
+        this.serverHealth = new Map();
+        this.credentialStates = new Map();
+        this.eventHandlers = new Map();
+        this.isDestroyed = false;
+        this.config = {
+            ...types_1.DEFAULT_TURN_MANAGER_CONFIG,
+            ...config,
+        };
+        // Initialize server health tracking
+        for (const server of this.config.servers) {
+            const url = this.getServerUrl(server);
+            this.serverHealth.set(url, {
+                server,
+                healthy: true, // Assume healthy until proven otherwise
+                latencyMs: Infinity,
+                lastCheckAt: 0,
+                failureCount: 0,
+            });
+        }
+        // Initialize credential states
+        for (const server of this.config.servers) {
+            if (server.expiresAt) {
+                const url = this.getServerUrl(server);
+                this.credentialStates.set(url, {
+                    credentials: server,
+                    fetchedAt: Date.now(),
+                    refreshing: false,
+                });
+                this.scheduleCredentialRefresh(server);
+            }
+        }
+        // Start health monitoring if enabled
+        if (this.config.enableHealthMonitoring) {
+            this.startHealthMonitoring();
+        }
+    }
+    /**
+     * Select optimal TURN server based on latency
+     *
+     * @returns Promise resolving to server selection with alternatives
+     */
+    async selectOptimalServer() {
+        const healthyServers = this.getHealthyServers();
+        if (healthyServers.length === 0) {
+            throw new Error('No healthy TURN servers available');
+        }
+        // Test latency to all healthy servers
+        const latencyResults = await this.testServerLatencies(healthyServers);
+        // Sort by latency
+        latencyResults.sort((a, b) => a.latencyMs - b.latencyMs);
+        const optimal = latencyResults[0];
+        const alternatives = latencyResults.slice(1);
+        return {
+            server: optimal.server,
+            latencyMs: optimal.latencyMs,
+            selectedAt: Date.now(),
+            alternatives,
+        };
+    }
+    /**
+     * Get ICE servers configuration for RTCPeerConnection
+     *
+     * @param includeUnhealthy - Include unhealthy servers (default: false)
+     * @returns Array of ICE server configurations
+     */
+    getICEServers(includeUnhealthy = false) {
+        const servers = includeUnhealthy
+            ? this.config.servers
+            : this.getHealthyServers();
+        return servers.map((server) => ({
+            urls: server.urls,
+            username: server.username,
+            credential: server.credential,
+            credentialType: server.credentialType,
+        }));
+    }
+    /**
+     * Get a specific server's current credentials
+     *
+     * @param serverUrl - Server URL to get credentials for
+     * @returns Server configuration with current credentials or null
+     */
+    getServerCredentials(serverUrl) {
+        const state = this.credentialStates.get(serverUrl);
+        return state?.credentials ?? null;
+    }
+    /**
+     * Manually refresh credentials for a server
+     *
+     * @param serverUrl - Server URL to refresh credentials for
+     * @returns Promise resolving to refreshed credentials
+     */
+    async refreshCredentials(serverUrl) {
+        const state = this.credentialStates.get(serverUrl);
+        if (!state) {
+            throw new Error(`No credential state for server: ${serverUrl}`);
+        }
+        if (!this.config.credentialConfig) {
+            throw new Error('No credential refresh configuration');
+        }
+        return this.fetchNewCredentials(serverUrl);
+    }
+    /**
+     * Add a new TURN server to the manager
+     *
+     * @param server - Server configuration to add
+     */
+    addServer(server) {
+        const url = this.getServerUrl(server);
+        if (this.serverHealth.has(url)) {
+            throw new Error(`Server already exists: ${url}`);
+        }
+        this.config.servers.push(server);
+        this.serverHealth.set(url, {
+            server,
+            healthy: true,
+            latencyMs: Infinity,
+            lastCheckAt: 0,
+            failureCount: 0,
+        });
+        if (server.expiresAt) {
+            this.credentialStates.set(url, {
+                credentials: server,
+                fetchedAt: Date.now(),
+                refreshing: false,
+            });
+            this.scheduleCredentialRefresh(server);
+        }
+    }
+    /**
+     * Remove a TURN server from the manager
+     *
+     * @param serverUrl - Server URL to remove
+     */
+    removeServer(serverUrl) {
+        const index = this.config.servers.findIndex((s) => this.getServerUrl(s) === serverUrl);
+        if (index !== -1) {
+            this.config.servers.splice(index, 1);
+        }
+        this.serverHealth.delete(serverUrl);
+        const state = this.credentialStates.get(serverUrl);
+        if (state?.refreshTimer) {
+            clearTimeout(state.refreshTimer);
+        }
+        this.credentialStates.delete(serverUrl);
+    }
+    /**
+     * Get server health status
+     *
+     * @param serverUrl - Server URL to check
+     * @returns Health status or null if not found
+     */
+    getServerHealth(serverUrl) {
+        return this.serverHealth.get(serverUrl) ?? null;
+    }
+    /**
+     * Get all server health statuses
+     *
+     * @returns Map of server URLs to health statuses
+     */
+    getAllServerHealth() {
+        return new Map(this.serverHealth);
+    }
+    /**
+     * Force health check for all servers
+     */
+    async checkAllServersHealth() {
+        const servers = Array.from(this.serverHealth.keys());
+        await Promise.all(servers.map((url) => this.checkServerHealth(url)));
+    }
+    /**
+     * Register event handler
+     *
+     * @param type - Event type to handle
+     * @param handler - Event handler function
+     * @returns Unsubscribe function
+     */
+    on(type, handler) {
+        if (!this.eventHandlers.has(type)) {
+            this.eventHandlers.set(type, new Set());
+        }
+        this.eventHandlers.get(type).add(handler);
+        return () => this.eventHandlers.get(type)?.delete(handler);
+    }
+    /**
+     * Get current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Destroy the manager and cleanup resources
+     */
+    destroy() {
+        this.isDestroyed = true;
+        // Stop health monitoring
+        if (this.healthCheckInterval) {
+            clearInterval(this.healthCheckInterval);
+            this.healthCheckInterval = undefined;
+        }
+        // Cancel all credential refresh timers
+        this.credentialStates.forEach((state) => {
+            if (state.refreshTimer) {
+                clearTimeout(state.refreshTimer);
+            }
+        });
+        this.credentialStates.clear();
+        this.serverHealth.clear();
+        this.eventHandlers.clear();
+    }
+    // ============================================
+    // Private Methods
+    // ============================================
+    getServerUrl(server) {
+        return Array.isArray(server.urls) ? server.urls[0] : server.urls;
+    }
+    getHealthyServers() {
+        const healthy = [];
+        this.serverHealth.forEach((health) => {
+            if (health.healthy) {
+                healthy.push(health.server);
+            }
+        });
+        return healthy;
+    }
+    async testServerLatencies(servers) {
+        const results = await Promise.all(servers.map(async (server) => {
+            const latencyMs = await this.measureLatency(server);
+            return { server, latencyMs };
+        }));
+        // Update health tracking with new latencies
+        for (const result of results) {
+            const url = this.getServerUrl(result.server);
+            const health = this.serverHealth.get(url);
+            if (health) {
+                health.latencyMs = result.latencyMs;
+                health.lastCheckAt = Date.now();
+                if (result.latencyMs < Infinity) {
+                    health.failureCount = 0;
+                    health.healthy = true;
+                }
+            }
+        }
+        return results;
+    }
+    async measureLatency(server) {
+        const startTime = performance.now();
+        try {
+            await this.testTurnConnectivity(server);
+            return performance.now() - startTime;
+        }
+        catch {
+            return Infinity;
+        }
+    }
+    async testTurnConnectivity(server) {
+        return new Promise((resolve, reject) => {
+            if (typeof RTCPeerConnection === 'undefined') {
+                reject(new Error('RTCPeerConnection not available'));
+                return;
+            }
+            const iceServer = {
+                urls: server.urls,
+                username: server.username,
+                credential: server.credential,
+            };
+            const pc = new RTCPeerConnection({
+                iceServers: [iceServer],
+                iceTransportPolicy: 'relay', // Force TURN usage
+            });
+            let resolved = false;
+            const timeout = setTimeout(() => {
+                if (!resolved) {
+                    resolved = true;
+                    pc.close();
+                    reject(new Error('TURN connectivity test timeout'));
+                }
+            }, this.config.latencyTestTimeout);
+            pc.onicecandidate = (event) => {
+                if (event.candidate && !resolved) {
+                    const candidate = event.candidate.candidate;
+                    // Look for relay candidate indicating TURN works
+                    if (candidate.includes('typ relay')) {
+                        resolved = true;
+                        clearTimeout(timeout);
+                        pc.close();
+                        resolve();
+                    }
+                }
+                else if (event.candidate === null && !resolved) {
+                    // Gathering complete without relay candidate
+                    resolved = true;
+                    clearTimeout(timeout);
+                    pc.close();
+                    reject(new Error('No relay candidate from TURN server'));
+                }
+            };
+            pc.onicegatheringstatechange = () => {
+                if (pc.iceGatheringState === 'complete' && !resolved) {
+                    resolved = true;
+                    clearTimeout(timeout);
+                    pc.close();
+                    reject(new Error('ICE gathering complete without relay'));
+                }
+            };
+            // Create data channel to trigger ICE gathering
+            pc.createDataChannel('turn-test');
+            pc.createOffer()
+                .then((offer) => pc.setLocalDescription(offer))
+                .catch((error) => {
+                if (!resolved) {
+                    resolved = true;
+                    clearTimeout(timeout);
+                    pc.close();
+                    reject(error);
+                }
+            });
+        });
+    }
+    async checkServerHealth(serverUrl) {
+        const health = this.serverHealth.get(serverUrl);
+        if (!health)
+            return;
+        try {
+            const latencyMs = await this.measureLatency(health.server);
+            if (latencyMs < Infinity) {
+                health.healthy = true;
+                health.latencyMs = latencyMs;
+                health.failureCount = 0;
+                health.lastError = undefined;
+            }
+            else {
+                throw new Error('Latency measurement failed');
+            }
+        }
+        catch (error) {
+            health.failureCount++;
+            health.lastError = error instanceof Error ? error.message : 'Unknown error';
+            // Mark as unhealthy after 3 consecutive failures
+            if (health.failureCount >= 3) {
+                health.healthy = false;
+            }
+        }
+        health.lastCheckAt = Date.now();
+    }
+    startHealthMonitoring() {
+        if (this.healthCheckInterval)
+            return;
+        this.healthCheckInterval = setInterval(() => {
+            if (!this.isDestroyed) {
+                this.checkAllServersHealth();
+            }
+        }, this.config.healthCheckInterval);
+    }
+    scheduleCredentialRefresh(server) {
+        if (!this.config.credentialConfig || !server.expiresAt)
+            return;
+        const url = this.getServerUrl(server);
+        const state = this.credentialStates.get(url);
+        if (!state)
+            return;
+        // Cancel existing timer
+        if (state.refreshTimer) {
+            clearTimeout(state.refreshTimer);
+        }
+        const expiresIn = server.expiresAt - Date.now();
+        const refreshIn = Math.max(0, expiresIn - this.config.credentialConfig.refreshBeforeExpiry);
+        state.refreshTimer = setTimeout(async () => {
+            if (!this.isDestroyed) {
+                try {
+                    await this.fetchNewCredentials(url);
+                }
+                catch (error) {
+                    console.error(`Failed to refresh credentials for ${url}:`, error);
+                }
+            }
+        }, refreshIn);
+    }
+    async fetchNewCredentials(serverUrl) {
+        if (!this.config.credentialConfig) {
+            throw new Error('No credential refresh configuration');
+        }
+        const state = this.credentialStates.get(serverUrl);
+        if (!state) {
+            throw new Error(`No credential state for server: ${serverUrl}`);
+        }
+        if (state.refreshing) {
+            // Wait for ongoing refresh
+            return new Promise((resolve, reject) => {
+                const checkInterval = setInterval(() => {
+                    if (!state.refreshing) {
+                        clearInterval(checkInterval);
+                        resolve(state.credentials);
+                    }
+                }, 100);
+                setTimeout(() => {
+                    clearInterval(checkInterval);
+                    reject(new Error('Credential refresh timeout'));
+                }, 30000);
+            });
+        }
+        state.refreshing = true;
+        let lastError = null;
+        for (let attempt = 0; attempt < this.config.credentialConfig.maxRetries; attempt++) {
+            try {
+                const newCredentials = await this.doCredentialFetch(serverUrl);
+                // Update state
+                state.credentials = newCredentials;
+                state.fetchedAt = Date.now();
+                state.refreshing = false;
+                // Update server in config
+                const index = this.config.servers.findIndex((s) => this.getServerUrl(s) === serverUrl);
+                if (index !== -1) {
+                    this.config.servers[index] = newCredentials;
+                }
+                // Update health tracking
+                const health = this.serverHealth.get(serverUrl);
+                if (health) {
+                    health.server = newCredentials;
+                }
+                // Schedule next refresh
+                this.scheduleCredentialRefresh(newCredentials);
+                this.emitEvent(types_1.NATEventType.CredentialsRefreshed, {
+                    server: serverUrl,
+                    expiresAt: newCredentials.expiresAt,
+                });
+                return newCredentials;
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error('Unknown error');
+                if (attempt < this.config.credentialConfig.maxRetries - 1) {
+                    await this.delay(this.config.credentialConfig.retryDelay);
+                }
+            }
+        }
+        state.refreshing = false;
+        throw lastError ?? new Error('Credential refresh failed');
+    }
+    async doCredentialFetch(serverUrl) {
+        if (!this.config.credentialConfig) {
+            throw new Error('No credential configuration');
+        }
+        const { refreshUrl, authToken } = this.config.credentialConfig;
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (authToken) {
+            headers['Authorization'] = `Bearer ${authToken}`;
+        }
+        const response = await fetch(refreshUrl, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({ server: serverUrl }),
+        });
+        if (!response.ok) {
+            throw new Error(`Credential refresh failed: ${response.status}`);
+        }
+        const data = await response.json();
+        // Validate response
+        if (!data.urls || !data.username || !data.credential) {
+            throw new Error('Invalid credential response format');
+        }
+        return {
+            urls: data.urls,
+            username: data.username,
+            credential: data.credential,
+            credentialType: data.credentialType || 'password',
+            expiresAt: data.expiresAt,
+            region: data.region,
+            priority: data.priority,
+        };
+    }
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    emitEvent(type, data) {
+        const handlers = this.eventHandlers.get(type);
+        if (handlers) {
+            const event = {
+                type,
+                timestamp: Date.now(),
+                data,
+            };
+            handlers.forEach((handler) => {
+                try {
+                    handler(event);
+                }
+                catch (error) {
+                    console.error(`TURN event handler error for ${type}:`, error);
+                }
+            });
+        }
+    }
+}
+exports.TURNManager = TURNManager;
+exports.default = TURNManager;
+//# sourceMappingURL=TURNManager.js.map