@astroanywhere/agent 0.1.0

package/dist/lib/websocket-client.js

@@ -0,0 +1,781 @@
+/**
+ * WebSocket client with automatic reconnection and heartbeat
+ */
+import WebSocket from 'ws';
+import jwt from 'jsonwebtoken';
+import { getMachineResources } from './resources.js';
+import { config as configManager } from './config.js';
+const DEFAULT_CONFIG = {
+    relayUrl: 'wss://relay.astro.dev',
+    maxConcurrentTasks: 4,
+    heartbeatInterval: 30000, // 30 seconds
+    reconnectMaxRetries: -1, // Infinite retries
+    reconnectBaseDelay: 1000, // 1 second
+    reconnectMaxDelay: 60000, // 1 minute
+    taskTimeout: 3600000, // 1 hour
+    logLevel: 'info',
+};
+export class WebSocketClient {
+    ws = null;
+    config;
+    runnerId;
+    machineId;
+    providers;
+    executionStrategies;
+    version;
+    wsToken;
+    reconnectAttempts = 0;
+    reconnectTimeout = null;
+    heartbeatInterval = null;
+    isConnecting = false;
+    shouldReconnect = true;
+    activeTasks = new Set();
+    pendingApprovals = new Map();
+    onEvent;
+    onTaskDispatch;
+    onTaskCancel;
+    onTaskSteer;
+    onTaskSafetyDecision;
+    onFileList;
+    onRepoSetup;
+    onSlashCommands;
+    onRepoDetect;
+    onGitInit;
+    constructor(options) {
+        this.runnerId = options.runnerId;
+        this.machineId = options.machineId;
+        this.providers = options.providers;
+        this.executionStrategies = options.executionStrategies;
+        this.version = options.version ?? '0.1.0';
+        this.wsToken = options.wsToken;
+        this.config = { ...DEFAULT_CONFIG, ...options.config };
+        this.onEvent = options.onEvent;
+        this.onTaskDispatch = options.onTaskDispatch;
+        this.onTaskCancel = options.onTaskCancel;
+        this.onTaskSteer = options.onTaskSteer;
+        this.onTaskSafetyDecision = options.onTaskSafetyDecision;
+        this.onFileList = options.onFileList;
+        this.onRepoSetup = options.onRepoSetup;
+        this.onSlashCommands = options.onSlashCommands;
+        this.onRepoDetect = options.onRepoDetect;
+        this.onGitInit = options.onGitInit;
+    }
+    /**
+     * Check if access token is expired or expiring soon
+     */
+    isTokenExpiring(token, bufferSeconds = 5 * 60) {
+        try {
+            const decoded = jwt.decode(token);
+            if (!decoded || !decoded.exp) {
+                return true; // Assume expired if we can't decode
+            }
+            const now = Math.floor(Date.now() / 1000);
+            return decoded.exp < now + bufferSeconds;
+        }
+        catch {
+            return true; // Assume expired on error
+        }
+    }
+    /**
+     * Refresh the access token and WebSocket token using the refresh token
+     */
+    async refreshAccessToken() {
+        const refreshToken = configManager.getRefreshToken();
+        if (!refreshToken) {
+            throw new Error('No refresh token available. Please run setup again to re-authenticate.');
+        }
+        const apiUrl = configManager.getApiUrl();
+        const response = await fetch(`${apiUrl}/api/device/refresh`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                refreshToken,
+                grantType: 'refresh_token',
+            }),
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+            throw new Error(`Token refresh failed: ${error.error || response.statusText}`);
+        }
+        const data = await response.json();
+        // Update stored tokens
+        configManager.setAccessToken(data.accessToken);
+        if (data.refreshToken) {
+            configManager.setRefreshToken(data.refreshToken);
+        }
+        if (data.wsToken) {
+            configManager.setWsToken(data.wsToken);
+        }
+        // Return wsToken for WebSocket connections (signed with RELAY_JWT_SECRET)
+        // Falls back to accessToken if server didn't return a wsToken
+        return data.wsToken || data.accessToken;
+    }
+    /**
+     * Ensure we have a valid WebSocket token before connecting.
+     * Returns null in dev mode when no token is configured (allows unauthenticated connections).
+     */
+    async ensureValidToken() {
+        let token = this.wsToken || configManager.getWsToken();
+        // In dev mode (non-wss relay), skip auth entirely
+        if (this.config.relayUrl.startsWith('ws://')) {
+            if (!token) {
+                return null;
+            }
+            // Even with a stale token, dev mode doesn't need auth
+            if (this.isTokenExpiring(token)) {
+                return null;
+            }
+        }
+        if (!token) {
+            throw new Error('No access token configured. Please run setup to authenticate.');
+        }
+        // Check if token is expired or expiring soon
+        if (this.isTokenExpiring(token)) {
+            console.log('[ws-client] Access token expired or expiring soon, refreshing...');
+            try {
+                token = await this.refreshAccessToken();
+                this.wsToken = token; // Update instance token
+                console.log('[ws-client] ✅ Access token refreshed successfully');
+            }
+            catch (error) {
+                console.error('[ws-client] ❌ Failed to refresh token:', error instanceof Error ? error.message : String(error));
+                throw new Error(`Authentication failed: ${error instanceof Error ? error.message : 'Token refresh failed'}. Please run setup again.`);
+            }
+        }
+        return token;
+    }
+    /**
+     * Connect to the relay server
+     */
+    async connect() {
+        if (this.isConnecting || this.ws?.readyState === WebSocket.OPEN) {
+            return;
+        }
+        this.isConnecting = true;
+        this.shouldReconnect = true;
+        // Ensure we have a valid token before connecting (null = dev mode, no auth)
+        let token;
+        try {
+            token = await this.ensureValidToken();
+        }
+        catch (error) {
+            this.isConnecting = false;
+            throw error;
+        }
+        return new Promise((resolve, reject) => {
+            try {
+                const headers = {
+                    'X-Runner-Id': this.runnerId,
+                    'X-Machine-Id': this.machineId,
+                };
+                if (token) {
+                    headers['Authorization'] = `Bearer ${token}`;
+                }
+                this.ws = new WebSocket(this.config.relayUrl, { headers });
+                this.ws.on('open', async () => {
+                    this.isConnecting = false;
+                    this.reconnectAttempts = 0;
+                    await this.handleOpen();
+                    resolve();
+                });
+                this.ws.on('message', (data) => {
+                    this.handleMessage(data);
+                });
+                const thisSocket = this.ws;
+                this.ws.on('close', (code, reason) => {
+                    // Only handle close if this is still the active socket.
+                    // When the server closes a stale connection after re-registration,
+                    // the old socket's close handler fires — ignore it to prevent a reconnect loop.
+                    if (this.ws !== thisSocket) {
+                        return;
+                    }
+                    this.handleClose(code, reason.toString());
+                });
+                this.ws.on('error', (error) => {
+                    this.isConnecting = false;
+                    if (this.reconnectAttempts === 0) {
+                        reject(error);
+                    }
+                    this.emitEvent({ type: 'error', error: error });
+                });
+                this.ws.on('pong', () => {
+                    // Server responded to ping, connection is alive
+                });
+            }
+            catch (error) {
+                this.isConnecting = false;
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Disconnect from the relay server
+     */
+    disconnect() {
+        this.shouldReconnect = false;
+        this.cleanup();
+        if (this.ws) {
+            this.ws.close(1000, 'Client disconnect');
+            this.ws = null;
+        }
+    }
+    /**
+     * Send a task status update
+     */
+    sendTaskStatus(taskId, status, progress, message) {
+        const msg = {
+            type: 'task_status',
+            timestamp: new Date().toISOString(),
+            payload: { taskId, status, progress, message },
+        };
+        this.send(msg);
+    }
+    /**
+     * Send task output (stdout/stderr)
+     */
+    sendTaskOutput(taskId, stream, data, sequence) {
+        const msg = {
+            type: 'task_output',
+            timestamp: new Date().toISOString(),
+            payload: { taskId, stream, data, sequence },
+        };
+        this.send(msg);
+    }
+    /**
+     * Send task result
+     */
+    sendTaskResult(result) {
+        const msg = {
+            type: 'task_result',
+            timestamp: new Date().toISOString(),
+            payload: result,
+        };
+        this.send(msg);
+        // Remove from active tasks
+        this.activeTasks.delete(result.taskId);
+    }
+    /**
+     * Send tool trace
+     */
+    sendToolTrace(taskId, toolName, toolInput, toolResult, success) {
+        const msg = {
+            type: 'task_tool_trace',
+            timestamp: new Date().toISOString(),
+            payload: { taskId, toolName, toolInput, toolResult, success },
+        };
+        this.send(msg);
+    }
+    /**
+     * Send structured text (bypasses stdout throttle on relay)
+     */
+    sendTaskText(taskId, text, sequence) {
+        const msg = {
+            type: 'task_text',
+            timestamp: new Date().toISOString(),
+            payload: { taskId, text, sequence },
+        };
+        this.send(msg);
+    }
+    /**
+     * Send structured tool use event
+     */
+    sendTaskToolUse(taskId, toolName, toolInput) {
+        const msg = {
+            type: 'task_tool_use',
+            timestamp: new Date().toISOString(),
+            payload: { taskId, toolName, toolInput },
+        };
+        this.send(msg);
+    }
+    /**
+     * Send structured tool result event
+     */
+    sendTaskToolResult(taskId, toolName, result, success) {
+        const msg = {
+            type: 'task_tool_result',
+            timestamp: new Date().toISOString(),
+            payload: { taskId, toolName, result, success },
+        };
+        this.send(msg);
+    }
+    /**
+     * Send structured file change event
+     */
+    sendTaskFileChange(taskId, path, action, linesAdded, linesRemoved, diff) {
+        const msg = {
+            type: 'task_file_change',
+            timestamp: new Date().toISOString(),
+            payload: { taskId, path, action, linesAdded, linesRemoved, diff },
+        };
+        this.send(msg);
+    }
+    /**
+     * Send structured session init event
+     */
+    sendTaskSessionInit(taskId, sessionId, model) {
+        const msg = {
+            type: 'task_session_init',
+            timestamp: new Date().toISOString(),
+            payload: { taskId, sessionId, model },
+        };
+        this.send(msg);
+    }
+    /**
+     * Send steer acknowledgment
+     */
+    sendSteerAck(taskId, accepted, message, interrupted) {
+        const msg = {
+            type: 'task_steer_ack',
+            timestamp: new Date().toISOString(),
+            payload: { taskId, accepted, message },
+        };
+        if (interrupted) {
+            msg.payload.interrupted = true;
+        }
+        this.send(msg);
+    }
+    /**
+     * Send approval request and wait for response (following Cyrus pattern)
+     * Returns a promise that resolves when the user responds or rejects on timeout
+     */
+    sendApprovalRequest(taskId, question, options) {
+        const requestId = `${taskId}-${Date.now()}`;
+        return new Promise((resolve, reject) => {
+            // Store the promise handlers
+            this.pendingApprovals.set(requestId, { resolve, reject });
+            // Send the approval request message
+            const msg = {
+                type: 'task_approval_request',
+                timestamp: new Date().toISOString(),
+                payload: { taskId, requestId, question, options },
+            };
+            this.send(msg);
+            console.log(`[ws-client] Sent approval request ${requestId} for task ${taskId}`);
+            // Set timeout (60 seconds for user to respond)
+            setTimeout(() => {
+                const pending = this.pendingApprovals.get(requestId);
+                if (pending) {
+                    this.pendingApprovals.delete(requestId);
+                    pending.resolve({ answered: false, message: 'Approval request timed out (60s)' });
+                }
+            }, 60000);
+        });
+    }
+    /**
+     * Send safety prompt to user
+     */
+    sendSafetyPrompt(taskId, safetyTier, warning, options) {
+        const msg = {
+            type: 'task_safety_prompt',
+            timestamp: new Date().toISOString(),
+            payload: {
+                taskId,
+                safetyTier,
+                warning,
+                blockReason: undefined,
+                options,
+            },
+        };
+        this.send(msg);
+        console.log(`[ws-client] Sent safety prompt for task ${taskId} (tier: ${safetyTier})`);
+    }
+    /**
+     * Send resource update
+     */
+    async sendResourceUpdate() {
+        const resources = await getMachineResources();
+        const msg = {
+            type: 'resource_update',
+            timestamp: new Date().toISOString(),
+            payload: { runnerId: this.runnerId, resources },
+        };
+        this.send(msg);
+    }
+    /**
+     * Check if connected
+     */
+    isConnected() {
+        return this.ws?.readyState === WebSocket.OPEN;
+    }
+    /**
+     * Get current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Get active task count
+     */
+    getActiveTaskCount() {
+        return this.activeTasks.size;
+    }
+    /**
+     * Add task to active set
+     */
+    addActiveTask(taskId) {
+        this.activeTasks.add(taskId);
+    }
+    /**
+     * Remove task from active set
+     */
+    removeActiveTask(taskId) {
+        this.activeTasks.delete(taskId);
+    }
+    // ============================================================================
+    // Private Methods
+    // ============================================================================
+    async handleOpen() {
+        // Send registration message
+        const resources = await getMachineResources();
+        // Allow config to override the display name (e.g., SSH alias like "nebius-2")
+        const machineName = configManager.getMachineName();
+        const registerMsg = {
+            type: 'register',
+            timestamp: new Date().toISOString(),
+            payload: {
+                runnerId: this.runnerId,
+                machineId: this.machineId,
+                ...(machineName ? { name: machineName } : {}),
+                providers: this.providers,
+                executionStrategies: this.executionStrategies,
+                resources,
+                version: this.version,
+            },
+        };
+        this.send(registerMsg);
+        // Start heartbeat
+        this.startHeartbeat();
+        this.emitEvent({ type: 'connected' });
+    }
+    handleMessage(data) {
+        try {
+            const raw = JSON.parse(data.toString());
+            // Handle task.steer (dot notation from relay) by normalizing to task_steer
+            if (raw.type === 'task.steer') {
+                // Relay sends: { type: 'task.steer', taskId, message, action, interrupt }
+                // Normalize to agent-runner format: { type: 'task_steer', payload: { taskId, message, action, interrupt } }
+                const steerMsg = {
+                    type: 'task_steer',
+                    timestamp: raw.timestamp ?? new Date().toISOString(),
+                    payload: {
+                        taskId: raw.taskId,
+                        message: raw.message,
+                        action: raw.action,
+                        interrupt: raw.interrupt,
+                    },
+                };
+                this.handleTaskSteer(steerMsg);
+                return;
+            }
+            // Handle file_list.request (dot notation from relay)
+            if (raw.type === 'file_list.request') {
+                const fileListMsg = {
+                    type: 'file_list_request',
+                    timestamp: raw.timestamp ?? new Date().toISOString(),
+                    payload: {
+                        path: raw.path,
+                        correlationId: raw.correlationId,
+                    },
+                };
+                this.handleFileListRequest(fileListMsg);
+                return;
+            }
+            // Handle slash_commands.request (dot notation from relay)
+            if (raw.type === 'slash_commands.request') {
+                const slashMsg = {
+                    type: 'slash_commands_request',
+                    timestamp: raw.timestamp ?? new Date().toISOString(),
+                    payload: {
+                        correlationId: raw.correlationId,
+                        workingDirectory: raw.workingDirectory,
+                    },
+                };
+                this.handleSlashCommandsRequest(slashMsg);
+                return;
+            }
+            // Handle repo_setup.request (dot notation from relay)
+            if (raw.type === 'repo_setup.request') {
+                const repoMsg = {
+                    type: 'repo_setup_request',
+                    timestamp: raw.timestamp ?? new Date().toISOString(),
+                    payload: raw.payload,
+                };
+                this.handleRepoSetupRequest(repoMsg);
+                return;
+            }
+            // Handle repo_detect.request (dot notation from relay)
+            if (raw.type === 'repo_detect.request') {
+                const detectMsg = {
+                    type: 'repo_detect_request',
+                    timestamp: raw.timestamp ?? new Date().toISOString(),
+                    payload: raw.payload,
+                };
+                this.handleRepoDetectRequest(detectMsg);
+                return;
+            }
+            // Handle git_init.request (dot notation from relay)
+            if (raw.type === 'git_init.request') {
+                const gitInitMsg = {
+                    type: 'git_init_request',
+                    timestamp: raw.timestamp ?? new Date().toISOString(),
+                    payload: raw.payload,
+                };
+                this.handleGitInitRequest(gitInitMsg);
+                return;
+            }
+            const message = raw;
+            this.routeMessage(message);
+        }
+        catch (error) {
+            this.emitEvent({ type: 'error', error: error });
+        }
+    }
+    routeMessage(message) {
+        switch (message.type) {
+            case 'registered':
+                this.handleRegistered(message);
+                break;
+            case 'heartbeat_ack':
+                // Heartbeat acknowledged, nothing to do
+                break;
+            case 'task_dispatch':
+                this.handleTaskDispatch(message);
+                break;
+            case 'task_cancel':
+                this.handleTaskCancel(message);
+                break;
+            case 'task_steer':
+                this.handleTaskSteer(message);
+                break;
+            case 'task_approval_response':
+                this.handleApprovalResponse(message);
+                break;
+            case 'task_safety_decision':
+                this.handleSafetyDecision(message);
+                break;
+            case 'config_update':
+                this.handleConfigUpdate(message);
+                break;
+            case 'file_list_request':
+                this.handleFileListRequest(message);
+                break;
+            case 'repo_setup_request':
+                this.handleRepoSetupRequest(message);
+                break;
+            case 'slash_commands_request':
+                this.handleSlashCommandsRequest(message);
+                break;
+            case 'repo_detect_request':
+                this.handleRepoDetectRequest(message);
+                break;
+            case 'git_init_request':
+                this.handleGitInitRequest(message);
+                break;
+            case 'error':
+                this.handleError(message);
+                break;
+        }
+    }
+    handleRegistered(message) {
+        // Apply server-provided configuration
+        if (message.payload.config) {
+            this.config = { ...this.config, ...message.payload.config };
+        }
+    }
+    handleTaskDispatch(message) {
+        const task = message.payload;
+        // Check if we can accept more tasks
+        if (this.activeTasks.size >= this.config.maxConcurrentTasks) {
+            this.sendTaskStatus(task.id, 'queued', 0, 'Waiting for available slot');
+            return;
+        }
+        this.activeTasks.add(task.id);
+        this.emitEvent({ type: 'task_received', task });
+        this.onTaskDispatch?.(task);
+    }
+    handleTaskCancel(message) {
+        const { taskId } = message.payload;
+        this.activeTasks.delete(taskId);
+        this.emitEvent({ type: 'task_cancelled', taskId });
+        this.onTaskCancel?.(taskId);
+    }
+    handleTaskSteer(message) {
+        const { taskId, message: steerMessage, action, interrupt } = message.payload;
+        this.onTaskSteer?.(taskId, steerMessage, action, interrupt);
+    }
+    handleSafetyDecision(message) {
+        const { taskId, decision } = message.payload;
+        console.log(`[ws-client] Received safety decision for ${taskId}: ${decision}`);
+        this.onTaskSafetyDecision?.(taskId, decision);
+    }
+    handleApprovalResponse(message) {
+        const { requestId, answered, answer, message: responseMessage } = message.payload;
+        const pending = this.pendingApprovals.get(requestId);
+        if (pending) {
+            console.log(`[ws-client] Received approval response for ${requestId}: answered=${answered}, answer=${answer}`);
+            this.pendingApprovals.delete(requestId);
+            pending.resolve({ answered, answer, message: responseMessage });
+        }
+        else {
+            console.warn(`[ws-client] Received approval response for unknown request ${requestId}`);
+        }
+    }
+    handleConfigUpdate(message) {
+        this.config = { ...this.config, ...message.payload };
+        // Restart heartbeat with new interval if changed
+        if (message.payload.heartbeatInterval) {
+            this.stopHeartbeat();
+            this.startHeartbeat();
+        }
+    }
+    handleError(message) {
+        const code = message.payload?.code ?? 'UNKNOWN';
+        const msg = message.payload?.message ?? 'Unknown error';
+        const error = new Error(`${code}: ${msg}`);
+        this.emitEvent({ type: 'error', error });
+    }
+    handleFileListRequest(message) {
+        const { path, correlationId } = message.payload;
+        this.onFileList?.(path, correlationId);
+    }
+    /**
+     * Send file list response
+     */
+    sendFileListResponse(correlationId, files) {
+        const msg = {
+            type: 'file_list_response',
+            timestamp: new Date().toISOString(),
+            payload: { correlationId, files },
+        };
+        this.send(msg);
+    }
+    handleRepoSetupRequest(message) {
+        this.onRepoSetup?.(message.payload);
+    }
+    handleSlashCommandsRequest(message) {
+        const { correlationId, workingDirectory } = message.payload;
+        this.onSlashCommands?.(correlationId, workingDirectory);
+    }
+    /**
+     * Send slash commands response
+     */
+    sendSlashCommandsResponse(correlationId, commands) {
+        const msg = {
+            type: 'slash_commands_response',
+            timestamp: new Date().toISOString(),
+            payload: { correlationId, commands },
+        };
+        this.send(msg);
+    }
+    /**
+     * Send repo setup response
+     */
+    sendRepoSetupResponse(correlationId, result) {
+        const msg = {
+            type: 'repo_setup_response',
+            timestamp: new Date().toISOString(),
+            payload: { correlationId, ...result },
+        };
+        this.send(msg);
+    }
+    handleRepoDetectRequest(message) {
+        this.onRepoDetect?.(message.payload);
+    }
+    /**
+     * Send repo detect response
+     */
+    sendRepoDetectResponse(correlationId, result) {
+        const msg = {
+            type: 'repo_detect_response',
+            timestamp: new Date().toISOString(),
+            payload: { correlationId, ...result },
+        };
+        this.send(msg);
+    }
+    handleGitInitRequest(message) {
+        this.onGitInit?.(message.payload);
+    }
+    /**
+     * Send git init response
+     */
+    sendGitInitResponse(correlationId, result) {
+        const msg = {
+            type: 'git_init_response',
+            timestamp: new Date().toISOString(),
+            payload: { correlationId, ...result },
+        };
+        this.send(msg);
+    }
+    handleClose(code, reason) {
+        this.cleanup();
+        this.emitEvent({ type: 'disconnected', reason: `${code}: ${reason}` });
+        // Custom close code 4001 means this connection was replaced by another
+        // process with the same machineId — do not reconnect.
+        if (code === 4001) {
+            console.error('[ws-client] Connection replaced by another process with the same machineId. Not reconnecting.');
+            this.shouldReconnect = false;
+            return;
+        }
+        if (this.shouldReconnect) {
+            this.scheduleReconnect();
+        }
+    }
+    send(message) {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(message));
+        }
+    }
+    startHeartbeat() {
+        this.heartbeatInterval = setInterval(async () => {
+            if (this.ws?.readyState === WebSocket.OPEN) {
+                // Send application-level heartbeat
+                const resources = await getMachineResources();
+                const heartbeat = {
+                    type: 'heartbeat',
+                    timestamp: new Date().toISOString(),
+                    payload: {
+                        runnerId: this.runnerId,
+                        activeTasks: Array.from(this.activeTasks),
+                        resources,
+                    },
+                };
+                this.send(heartbeat);
+                // Also send WebSocket ping for connection health
+                this.ws.ping();
+            }
+        }, this.config.heartbeatInterval);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+    }
+    scheduleReconnect() {
+        const maxRetries = this.config.reconnectMaxRetries;
+        if (maxRetries >= 0 && this.reconnectAttempts >= maxRetries) {
+            return;
+        }
+        this.reconnectAttempts++;
+        // Exponential backoff with jitter
+        const delay = Math.min(this.config.reconnectBaseDelay * Math.pow(2, this.reconnectAttempts - 1) +
+            Math.random() * 1000, this.config.reconnectMaxDelay);
+        this.emitEvent({ type: 'reconnecting', attempt: this.reconnectAttempts });
+        this.reconnectTimeout = setTimeout(() => {
+            this.connect().catch(() => {
+                // Error already handled in connect()
+            });
+        }, delay);
+    }
+    cleanup() {
+        this.stopHeartbeat();
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+            this.reconnectTimeout = null;
+        }
+    }
+    emitEvent(event) {
+        this.onEvent?.(event);
+    }
+}
+//# sourceMappingURL=websocket-client.js.map