Function open

hub/src/web/server.ts:84–138

(clientWs: ServerWebSocket<unknown>)

    return {
        open(clientWs: ServerWebSocket<unknown>) {
            const data = clientWs.data as {
                _geminiProxy: boolean
                apiKey: string
                language?: string
                voiceName?: string
                systemInstruction?: string
                affectiveDialog?: boolean
            }
            const upstreamUrl = `${process.env.GEMINI_LIVE_WS_URL || GEMINI_WS_BASE}?key=${encodeURIComponent(data.apiKey)}`
            const pending: Array<string | ArrayBuffer | Uint8Array> = []
            pendingMap.set(clientWs, pending)
            pendingBytesMap.set(clientWs, 0)

            const upstream = new WebSocket(upstreamUrl)
            upstreamMap.set(clientWs, upstream)

            upstream.onopen = () => {
                // Hub-owned setup only — never forward client setup (prevents generic Gemini proxy abuse).
                // Do NOT flush pending here: wait for Google's setupComplete before forwarding client frames.
                upstream.send(JSON.stringify(buildGeminiLiveSetupMessage(
                    data.language,
                    data.voiceName,
                    data.systemInstruction,
                    { affectiveDialog: data.affectiveDialog }
                )))
            }
            upstream.onmessage = (event) => {
                try {
                    if (clientWs.readyState === 1) {
                        clientWs.send(typeof event.data === 'string' ? event.data : new Uint8Array(event.data as ArrayBuffer))
                    }
                } catch { /* client gone */ }
                // Flush queued client frames only after Google acknowledges setup.
                const pending = pendingMap.get(clientWs)
                if (pending && isGeminiSetupCompleteFrame(event.data as string | ArrayBuffer)) {
                    pendingMap.delete(clientWs)
                    pendingBytesMap.delete(clientWs)
                    for (const queued of pending) {
                        try { upstream.send(queued) } catch { /* upstream gone */ }
                    }
                }
            }
            upstream.onerror = () => {
                pendingMap.delete(clientWs)
                pendingBytesMap.delete(clientWs)
                try { clientWs.close(1011, 'Upstream error') } catch { /* */ }
            }
            upstream.onclose = (event) => {
                pendingMap.delete(clientWs)
                pendingBytesMap.delete(clientWs)
                try { clientWs.close(toClientCloseCode(event.code), event.reason || 'Upstream closed') } catch { /* client gone */ }
                upstreamMap.delete(clientWs)
            }
        },
        message(clientWs: ServerWebSocket<unknown>, message: string | ArrayBuffer | Uint8Array) {
            if (isGeminiSetupFrame(message)) {
                try { clientWs.close(1008, 'Client-provided Gemini setup is not allowed') } catch { /* */ }