Spaces:
Sleeping
Sleeping
Download dashboard/src/hooks/useWebSocket.ts from jinksQspider/openWa: direct link, hf CLI and curl.
- Browser
- Download file 5.72 kB
-
https://huggingface.co/spaces/jinksQspider/openWa/resolve/main/dashboard/src/hooks/useWebSocket.ts
- Command line
-
hf download hf://spaces/jinksQspider/openWa/dashboard/src/hooks/useWebSocket.ts
-
curl -L -o useWebSocket.ts https://huggingface.co/spaces/jinksQspider/openWa/resolve/main/dashboard/src/hooks/useWebSocket.ts
5.72 kB
| import { useEffect, useRef, useCallback, useState } from 'react'; | |
| import { io, Socket } from 'socket.io-client'; | |
| interface SessionStatusEvent { | |
| sessionId: string; | |
| status: string; | |
| timestamp: string; | |
| } | |
| interface QRCodeEvent { | |
| sessionId: string; | |
| qrCode: string; | |
| timestamp: string; | |
| } | |
| interface MessageEvent { | |
| sessionId: string; | |
| message: Record<string, unknown>; | |
| timestamp: string; | |
| } | |
| interface MessageAckEvent { | |
| sessionId: string; | |
| messageId: string; | |
| ack: number; | |
| ackName: string; | |
| chatId?: string; | |
| timestamp: string; | |
| } | |
| interface MessageReactionEvent { | |
| sessionId: string; | |
| messageId: string; | |
| chatId: string; | |
| reaction: string; | |
| senderId: string; | |
| reactions: Record<string, string>; | |
| timestamp: string; | |
| } | |
| interface MessageRevokedEvent { | |
| sessionId: string; | |
| id: string; | |
| chatId: string; | |
| from: string; | |
| to: string; | |
| body: string; | |
| type: string; | |
| timestamp: number; | |
| } | |
| interface WebSocketEvents { | |
| onSessionStatus?: (event: SessionStatusEvent) => void; | |
| onQRCode?: (event: QRCodeEvent) => void; | |
| onMessage?: (event: MessageEvent) => void; | |
| onMessageAck?: (event: MessageAckEvent) => void; | |
| onMessageReaction?: (event: MessageReactionEvent) => void; | |
| onMessageRevoked?: (event: MessageRevokedEvent) => void; | |
| } | |
| // Shape of the server -> client event envelope produced by the NestJS gateway. | |
| interface ServerEventEnvelope { | |
| type: string; | |
| timestamp: string; | |
| payload?: { | |
| event: string; | |
| sessionId: string; | |
| data: Record<string, unknown>; | |
| }; | |
| } | |
| // Use current origin for WebSocket (goes through nginx proxy in Docker) | |
| // Falls back to env var or localhost for development | |
| const SOCKET_URL = import.meta.env.VITE_WS_URL || window.location.origin; | |
| export function useWebSocket(events: WebSocketEvents = {}) { | |
| const socketRef = useRef<Socket | null>(null); | |
| const [isConnected, setIsConnected] = useState(false); | |
| const connect = useCallback(() => { | |
| if (socketRef.current?.connected) return; | |
| // Get API key from sessionStorage (same as api.ts) | |
| const apiKey = sessionStorage.getItem('openwa_api_key'); | |
| if (!apiKey) { | |
| console.warn('[WebSocket] No API key found, skipping connection'); | |
| return; | |
| } | |
| socketRef.current = io(`${SOCKET_URL}/events`, { | |
| autoConnect: true, | |
| reconnection: true, | |
| reconnectionAttempts: 5, | |
| reconnectionDelay: 1000, | |
| auth: { | |
| apiKey, | |
| }, | |
| extraHeaders: { | |
| 'X-API-Key': apiKey, | |
| }, | |
| query: { | |
| apiKey, | |
| }, | |
| }); | |
| socketRef.current.on('connect', () => { | |
| setIsConnected(true); | |
| }); | |
| socketRef.current.on('disconnect', () => { | |
| setIsConnected(false); | |
| }); | |
| socketRef.current.on('connect_error', error => { | |
| console.warn('[WebSocket] Connection error:', error.message); | |
| }); | |
| }, []); | |
| const subscribe = useCallback((sessionId: string, eventsList: string[]) => { | |
| if (socketRef.current?.connected) { | |
| socketRef.current.emit('message', { | |
| type: 'subscribe', | |
| sessionId, | |
| events: eventsList, | |
| }); | |
| } | |
| }, []); | |
| const unsubscribe = useCallback((sessionId: string) => { | |
| if (socketRef.current?.connected) { | |
| socketRef.current.emit('message', { | |
| type: 'unsubscribe', | |
| sessionId, | |
| }); | |
| } | |
| }, []); | |
| useEffect(() => { | |
| connect(); | |
| return () => { | |
| if (socketRef.current) { | |
| socketRef.current.disconnect(); | |
| socketRef.current = null; | |
| } | |
| }; | |
| }, [connect]); | |
| // Register the single envelope handler and fan out to the typed callbacks. | |
| useEffect(() => { | |
| if (!socketRef.current) return; | |
| const socket = socketRef.current; | |
| const handleIncomingMessage = (msg: ServerEventEnvelope) => { | |
| if (!msg || msg.type !== 'event' || !msg.payload) return; | |
| const { event, sessionId, data } = msg.payload; | |
| switch (event) { | |
| case 'session.status': | |
| events.onSessionStatus?.({ sessionId, status: String(data.status), timestamp: msg.timestamp }); | |
| break; | |
| case 'session.qr': | |
| events.onQRCode?.({ sessionId, qrCode: String(data.qrCode), timestamp: msg.timestamp }); | |
| break; | |
| case 'message.received': | |
| case 'message.sent': | |
| events.onMessage?.({ sessionId, message: data, timestamp: msg.timestamp }); | |
| break; | |
| case 'message.ack': | |
| events.onMessageAck?.({ | |
| sessionId, | |
| messageId: String(data.messageId), | |
| ack: Number(data.ack), | |
| ackName: String(data.ackName), | |
| chatId: data.chatId as string | undefined, | |
| timestamp: msg.timestamp, | |
| }); | |
| break; | |
| case 'message.reaction': | |
| events.onMessageReaction?.({ | |
| sessionId, | |
| messageId: String(data.messageId), | |
| chatId: String(data.chatId), | |
| reaction: String(data.reaction), | |
| senderId: String(data.senderId), | |
| reactions: (data.reactions as Record<string, string>) || {}, | |
| timestamp: msg.timestamp, | |
| }); | |
| break; | |
| case 'message.revoked': | |
| events.onMessageRevoked?.({ | |
| sessionId, | |
| id: String(data.id), | |
| chatId: String(data.chatId), | |
| from: String(data.from), | |
| to: String(data.to), | |
| body: String(data.body ?? ''), | |
| type: String(data.type), | |
| timestamp: Number(data.timestamp), | |
| }); | |
| break; | |
| default: | |
| break; | |
| } | |
| }; | |
| socket.on('message', handleIncomingMessage); | |
| return () => { | |
| socket.off('message', handleIncomingMessage); | |
| }; | |
| }, [events]); | |
| return { isConnected, subscribe, unsubscribe }; | |
| } | |