@vibexnpm/talkx 2.3.1

package/src/talkflow/delegates.js

@@ -0,0 +1,112 @@
+const CHAT_DELEGATE_METHODS = [
+    'getRooms',
+    'getRoom',
+    'getRoomInfo',
+    'setMyRoomLanguage',
+    'createOneToOneRoom',
+    'createGroupRoom',
+    'joinGroupRoom',
+    'leaveRoom',
+    'updateGroupRoom',
+    'inviteToGroupRoom',
+    'kickMember',
+    'banMember',
+    'unbanMember',
+    'getBannedMembers',
+    'getAvailableGroupRooms',
+    'getAllGroupRooms',
+    'enterRoom',
+    'getMessages',
+    'fetchLinkPreview',
+    'sendMessage',
+    'sendMessageOptimistic',
+    'sendTextMessage',
+    'sendTextMessageOptimistic',
+    'sendReply',
+    'sendReplyOptimistic',
+    'uploadFile',
+    'sendFileMessage',
+    'sendFileMessageOptimistic',
+    'editMessage',
+    'deleteMessage',
+    'markAsRead',
+    'pinMessage',
+    'unpinMessage',
+    'toggleReaction',
+    'subscribeRoom',
+    'unsubscribeRoom',
+    'unsubscribeAllRooms',
+    'setActiveRoom',
+    'clearActiveRoom',
+    'getActiveRoom',
+    'subscribeRoomList',
+    'unsubscribeRoomList',
+    'isRoomListSubscribed',
+    'getSubscribedRooms',
+    'isSubscribed',
+    'startTyping',
+    'stopTyping',
+    'getAssistants',
+    'getRoomAiMeta',
+    'rateAssistantMessage',
+    'summarizeWithAssistant',
+    'translateWithAssistant',
+    'getRoomPmPrompt',
+    'upsertRoomPmPrompt',
+    'activateRoomPmPrompt',
+    'deactivateRoomPmPrompt',
+    'getRoomPmPromptVersions',
+    'activateRoomPmPromptVersion',
+    'previewRoomPmPrompt'
+];
+
+const WEBRTC_DELEGATE_METHODS = [
+    'initializeIceServers',
+    'getTurnCredentials',
+    'createCallRoom',
+    'getCallRoom',
+    'joinCallRoomApi',
+    'leaveCallRoomApi',
+    'enableIncomingCalls',
+    'disableIncomingCalls',
+    'isIncomingCallsEnabled',
+    'startCall',
+    'callUser',
+    'acceptCall',
+    'rejectCall',
+    'cancelCall',
+    'endCall',
+    'toggleVideo',
+    'toggleAudio',
+    'setVideoEnabled',
+    'setAudioEnabled',
+    'startScreenShare',
+    'stopScreenShare',
+    'getLocalStream',
+    'getDevices',
+    'switchDevice',
+    'startDeviceChangeDetection',
+    'stopDeviceChangeDetection',
+    'applyVideoConstraints',
+    'getVideoSettings',
+    'getAudioSettings',
+    'isInCall',
+    'getCurrentRoom',
+    'getParticipants',
+    'getMediaState',
+    'getConnectionSummary',
+    'getStats'
+];
+
+function defineDelegates(prototype, targetKey, methods) {
+    methods.forEach((method) => {
+        prototype[method] = function delegatedMethod(...args) {
+            return this[targetKey][method](...args);
+        };
+    });
+}
+
+export function applyDelegatedMethods(TalkFlowClient) {
+    defineDelegates(TalkFlowClient.prototype, 'chat', CHAT_DELEGATE_METHODS);
+    defineDelegates(TalkFlowClient.prototype, 'webrtc', WEBRTC_DELEGATE_METHODS);
+}

package/src/talkflow/eventForwarding.js

@@ -0,0 +1,93 @@
+const CONNECTION_EVENT_MAP = [
+    ['connected', 'connected'],
+    ['disconnected', 'disconnected'],
+    ['reconnecting', 'reconnecting'],
+    ['error', 'connectionError']
+];
+
+const CHAT_EVENT_MAP = [
+    ['message', 'chatMessage'],
+    ['newMessage', 'newChatMessage'],
+    ['messageUpdated', 'messageUpdated'],
+    ['messageDeleted', 'messageDeleted'],
+    ['reactionChanged', 'reactionChanged'],
+    ['linkPreviewAttached', 'linkPreviewAttached'],
+    ['messageTranslated', 'messageTranslated'],
+    ['messageRead', 'messageRead'],
+    ['typing', 'typing'],
+    ['memberJoined', 'memberJoined'],
+    ['memberLeft', 'memberLeft'],
+    ['roomSubscribed', 'roomSubscribed'],
+    ['roomUnsubscribed', 'roomUnsubscribed'],
+    ['roomListSubscribed', 'roomListSubscribed'],
+    ['roomListUnsubscribed', 'roomListUnsubscribed'],
+    ['roomListUpdate', 'roomListUpdate'],
+    ['roomListMessage', 'roomListMessage'],
+    ['roomListCreated', 'roomListCreated'],
+    ['roomListJoined', 'roomListJoined'],
+    ['roomListLeft', 'roomListLeft'],
+    ['roomListSelfLeft', 'roomListSelfLeft'],
+    ['roomListKicked', 'roomListKicked'],
+    ['roomListSelfKicked', 'roomListSelfKicked'],
+    ['roomListBanned', 'roomListBanned'],
+    ['roomListSelfBanned', 'roomListSelfBanned'],
+    ['roomListRoomUpdated', 'roomListRoomUpdated'],
+    ['retentionCleanup', 'retentionCleanup']
+];
+
+const WEBRTC_EVENT_MAP = [
+    ['localStreamStarted', 'localStreamStarted'],
+    ['localStreamStopped', 'localStreamStopped'],
+    ['remoteTrack', 'remoteTrack'],
+    ['screenShareStarted', 'screenShareStarted'],
+    ['screenShareEnded', 'screenShareEnded'],
+    ['deviceChange', 'deviceChange'],
+    ['mediaStateChanged', 'mediaStateChanged'],
+    ['callStarted', 'callStarted'],
+    ['callEnded', 'callEnded'],
+    ['callRequested', 'callRequested'],
+    ['callAccepted', 'callAccepted'],
+    ['callRejected', 'callRejected'],
+    ['callCancelled', 'callCancelled'],
+    ['callBusy', 'callBusy'],
+    ['incomingCall', 'incomingCall'],
+    ['incomingCallWhileBusy', 'incomingCallWhileBusy'],
+    ['callInvitation', 'callInvitation'],
+    ['userJoined', 'userJoined'],
+    ['userLeft', 'userLeft'],
+    ['participantLeft', 'participantLeft'],
+    ['participantMediaState', 'participantMediaState'],
+    ['peerConnected', 'peerConnected'],
+    ['peerDisconnected', 'peerDisconnected'],
+    ['peerClosed', 'peerClosed'],
+    ['error', 'webrtcError']
+];
+
+function forwardMappedEvents(source, target, eventMap) {
+    eventMap.forEach(([sourceEvent, targetEvent]) => {
+        source.on(sourceEvent, (data) => {
+            target.emit(targetEvent, data);
+        });
+    });
+}
+
+export function setupEventForwarding(client) {
+    if (!client.connectionManager) {
+        return;
+    }
+
+    client.connectionManager.on('stateChange', ({ state, prevState }) => {
+        client._state = state;
+        client.emit('stateChange', { state, prevState });
+    });
+
+    forwardMappedEvents(client.connectionManager, client, CONNECTION_EVENT_MAP);
+
+    if (client.chat) {
+        forwardMappedEvents(client.chat, client, CHAT_EVENT_MAP);
+    }
+
+    if (client.webrtc) {
+        forwardMappedEvents(client.webrtc, client, WEBRTC_EVENT_MAP);
+    }
+}

package/src/talkflow/session.js

@@ -0,0 +1,355 @@
+import { validateAndParseJWT, isJWTExpired } from '../utils/jwtUtils.js';
+import ConnectionManager from '../core/ConnectionManager.js';
+import ChatClient from '../chat/ChatClient.js';
+import WebRTCClient from '../webrtc/WebRTCClient.js';
+import PushManager from '../push/PushManager.js';
+
+export function initializeSubClients(client) {
+    if (client.connectionManager) {
+        return;
+    }
+
+    if (!client.userId) {
+        throw new Error('userId is required to initialize sub-clients. Please set JWT token first.');
+    }
+
+    client.connectionManager = new ConnectionManager({
+        serverUrl: client.options.serverUrl,
+        jwtToken: client.options.jwtToken,
+        apiKey: client.options.apiKey,
+        projectId: client.options.projectId,
+        useSockJS: client.options.useSockJS,
+        reconnectDelay: client.options.reconnectDelay,
+        maxReconnectAttempts: client.options.maxReconnectAttempts,
+        logLevel: client.options.logLevel
+    });
+
+    client._chat = new ChatClient({
+        connectionManager: client.connectionManager,
+        apiClient: client.apiClient,
+        userId: client._userId,
+        logLevel: client.options.logLevel
+    });
+
+    client._webrtc = new WebRTCClient({
+        connectionManager: client.connectionManager,
+        apiClient: client.apiClient,
+        userId: client._userId,
+        iceServers: client.options.iceServers,
+        logLevel: client.options.logLevel
+    });
+
+    client._setupEventForwarding();
+    client.logger.debug('Sub-clients initialized');
+}
+
+export function applySessionMethods(TalkFlowClient) {
+    TalkFlowClient.prototype.connect = async function connect(jwt, options = {}) {
+        const { enablePush = false } = options;
+
+        if (jwt) {
+            await this.setToken(jwt);
+        }
+
+        if (!this.options.jwtToken) {
+            throw new Error(
+                'JWT token is required. Obtain it from your backend (which calls ' +
+                'POST /api/v1/users/auth with a Server API Key) and pass it to the SDK ' +
+                'via the jwtToken option, setToken(), or connect(jwt). See README "프로덕션 인증 플로우".'
+            );
+        }
+
+        if (isJWTExpired(this.options.jwtToken)) {
+            throw new Error('JWT token has expired. Please update the token before connecting.');
+        }
+
+        if (!this.connectionManager) {
+            this._initializeSubClients();
+        }
+
+        await this.connectionManager.connect();
+
+        if (this.webrtc) {
+            await this.webrtc.enableIncomingCalls();
+        }
+
+        if (this.chat && this.options.autoSubscribeRoomList) {
+            try {
+                await this.chat.subscribeRoomList();
+            } catch (error) {
+                this.logger.warn('Failed to auto-subscribe room list (non-fatal):', error);
+            }
+        }
+
+        if (enablePush) {
+            this.enablePushNotifications();
+        }
+
+        this.logger.info('Connected to server');
+    };
+
+    TalkFlowClient.prototype.disconnect = async function disconnect() {
+        if (!this.connectionManager) {
+            return;
+        }
+
+        if (this.webrtc && this.webrtc.isInCall()) {
+            this.webrtc.endCall();
+        }
+
+        if (this.webrtc) {
+            this.webrtc.disableIncomingCalls();
+        }
+
+        if (this.chat) {
+            this.chat.unsubscribeAllRooms();
+            this.chat.unsubscribeRoomList();
+        }
+
+        await this.connectionManager.disconnect();
+        this.logger.info('Disconnected from server');
+    };
+
+    TalkFlowClient.prototype.logout = async function logout() {
+        try {
+            await this.apiClient.post('/v1/auth/signout');
+            this.logger.info('Logged out from server');
+        } catch (error) {
+            this.logger.warn('Server logout failed (proceeding with local cleanup):', error.message);
+        }
+
+        await this.disconnect();
+
+        if (this.pushManager) {
+            this.pushManager.reset();
+            this._pushEnablePromise = null;
+        }
+
+        this.options.jwtToken = null;
+        this._userId = null;
+        this.apiClient.setJwtToken(null);
+
+        this.emit('loggedOut');
+    };
+
+    /**
+     * 웹 푸시 알림을 활성화한다.
+     *
+     * <p>전체 흐름: Firebase 초기화 → 서비스 워커 등록 → 권한 요청 → FCM 토큰 발급 → 서버 등록 →
+     * 포그라운드 메시지 핸들러 등록 → SW 에 projectId 등록.</p>
+     *
+     * <h3>호출 패턴</h3>
+     * <ul>
+     *   <li><b>자동 활성화 (비차단)</b> — {@code client.enablePushNotifications();} 처럼
+     *       await 없이 호출하면 fire-and-forget 으로 동작한다. 메인 흐름 (UI 렌더링 등) 을 차단하지 않는다.
+     *       이 경우 결과는 {@code 'pushEnabled'} / {@code 'pushFailed'} 이벤트로 받는다.
+     *       <b>중요</b>: 이 패턴을 쓸 때는 호출 <b>전에</b> 이벤트 리스너를 등록해야 한다 — 그렇지 않으면
+     *       즉시 emit 되는 실패 이벤트를 놓칠 수 있다.</li>
+     *   <li><b>사용자 액션 (await)</b> — 버튼 클릭 등 사용자 명시적 액션에서는
+     *       {@code const result = await client.enablePushNotifications();} 으로 결과를 즉시 받아서
+     *       UI 분기에 사용한다. throw 하지 않으므로 try/catch 불필요.</li>
+     * </ul>
+     *
+     * <p>이 메서드는 throw 하지 않는다. 실패는 {@code { ok: false, reason, error }} 형태의 객체로 반환된다.
+     * 따라서 fire-and-forget 으로 호출해도 unhandled rejection 이 발생하지 않는다.</p>
+     *
+     * @param {Object} [options]
+     * @param {Object} [options.firebaseConfig] - 커스텀 Firebase 설정 (테스트/검증용)
+     * @param {string} [options.vapidKey] - 커스텀 VAPID 키
+     * @param {string} [options.serviceWorkerPath] - 서비스 워커 경로
+     * @returns {Promise<{ok: true, alreadyEnabled?: boolean} | {ok: false, reason: string, error: Error}>}
+     *     성공 시 {@code { ok: true }}, 실패 시 {@code { ok: false, reason, error }}.
+     *     {@code reason} 은 {@link PushErrorCode} 값 또는 {@code 'NO_TOKEN'}.
+     */
+    TalkFlowClient.prototype.enablePushNotifications = async function enablePushNotifications(options = {}) {
+        // JWT 토큰 미설정 시 명확한 분류 에러로 통보 (throw 하지 않고 결과 객체 반환).
+        if (!this.options.jwtToken) {
+            const error = new Error('JWT token is required to enable push notifications.');
+            this.emit('pushFailed', { reason: 'NO_TOKEN', error });
+            return { ok: false, reason: 'NO_TOKEN', error };
+        }
+
+        if (!this.pushManager) {
+            this._pushManager = new PushManager({
+                apiClient: this.apiClient,
+                projectId: this.options.projectId,
+                firebaseConfig: options.firebaseConfig,
+                vapidKey: options.vapidKey,
+                serviceWorkerPath: options.serviceWorkerPath,
+                logLevel: this.options.logLevel
+            });
+
+            // 포그라운드 메시지 콜백 — projectId 필터링 + activeRoom suppress + messageId dedup 후 client emit.
+            // PushManager 자체는 EventEmitter 가 아니므로 콜백 오버라이드로 우회한다.
+            //
+            // dedup: 같은 messageId 의 푸시가 서버측 멱등 race 복구 / FCM 재전송 등으로 중복 도착할 수 있어
+            // 5분 TTL Map 으로 한 번만 emit. setTimeout 으로 자동 cleanup.
+            const PUSH_DEDUP_TTL_MS = 5 * 60 * 1000;
+            this.pushManager._onForegroundMessage = (payload) => {
+                const data = payload.data || {};
+
+                if (data.projectId && data.projectId !== this.options.projectId) {
+                    this.logger.debug('다른 프로젝트 푸시 무시:', data.projectId);
+                    return;
+                }
+
+                const activeRoomId = this.chat?.getActiveRoom();
+
+                if (activeRoomId && activeRoomId === data.roomId) {
+                    this.logger.debug('포그라운드 푸시 suppress (현재 방):', data.roomId);
+                    return;
+                }
+
+                // messageId 기반 dedup — 키가 없는 시스템 푸시 등은 통과.
+                if (data.messageId) {
+                    if (!this._recentPushMessageIds) {
+                        this._recentPushMessageIds = new Map();
+                    }
+                    if (this._recentPushMessageIds.has(data.messageId)) {
+                        this.logger.debug('포그라운드 푸시 dedup:', data.messageId);
+                        return;
+                    }
+                    const timer = setTimeout(() => {
+                        this._recentPushMessageIds.delete(data.messageId);
+                    }, PUSH_DEDUP_TTL_MS);
+                    this._recentPushMessageIds.set(data.messageId, timer);
+                }
+
+                this.emit('pushNotification', {
+                    title: payload.notification?.title || data.title,
+                    body: payload.notification?.body || data.body,
+                    data
+                });
+            };
+        }
+
+        // 가드 1: 이미 활성화됨 — 중복 호출은 성공으로 간주.
+        if (this.pushManager.isEnabled()) {
+            this.logger.debug('웹 푸시가 이미 활성화되어 있어 중복 호출을 건너뜁니다.');
+            return { ok: true, alreadyEnabled: true };
+        }
+
+        // 가드 2: 진행 중 — 같은 Promise 를 공유해 두 호출자가 동일 결과를 받도록 한다.
+        if (this._pushEnablePromise) {
+            this.logger.debug('웹 푸시 활성화가 이미 진행 중입니다.');
+            return this._pushEnablePromise;
+        }
+
+        // 본 활성화 흐름 — throw 하지 않고 결과 객체로 통일.
+        // try/catch 안에서 emit + return 모두 처리하여 fire-and-forget 호출자도 안전하게 한다.
+        const promise = (async () => {
+            try {
+                await this.pushManager.enable();
+                this.emit('pushEnabled');
+                return { ok: true };
+            } catch (error) {
+                // PushError 면 분류 코드 사용, 아니면 'UNKNOWN'.
+                const reason = (error && error.code) ? error.code : 'UNKNOWN';
+                this.logger.warn('Failed to enable push notifications:', reason, error?.message);
+                this.emit('pushFailed', { reason, error });
+                return { ok: false, reason, error };
+            }
+        })();
+
+        this._pushEnablePromise = promise;
+
+        // self-clear — 본인이 현재 진행 중인 Promise 일 때만 null 처리 (race 방지).
+        promise.finally(() => {
+            if (this._pushEnablePromise === promise) {
+                this._pushEnablePromise = null;
+            }
+        });
+
+        return promise;
+    };
+
+    TalkFlowClient.prototype.consumePendingRoom = async function consumePendingRoom() {
+        return PushManager.consumePendingRoom(this.options.projectId);
+    };
+
+    TalkFlowClient.prototype.setCurrentDeviceEnabled = function setCurrentDeviceEnabled(enabled) {
+        return this.pushManager?.setCurrentDeviceEnabled(enabled);
+    };
+
+    TalkFlowClient.prototype.setDeviceEnabled = function setDeviceEnabled(deviceId, enabled) {
+        return this.pushManager?.setDeviceEnabled(deviceId, enabled);
+    };
+
+    TalkFlowClient.prototype.getMyDevices = function getMyDevices() {
+        return this.pushManager?.getMyDevices();
+    };
+
+    /**
+     * 현재 브라우저의 푸시 권한 상태를 조회한다.
+     *
+     * <p>{@code enablePushNotifications()} 호출 <b>전에도</b> 사용 가능 — pushManager 인스턴스 불필요.
+     * UI 분기 (granted → 자동 enable / default → 버튼 노출 / denied → 설정 가이드 / unsupported → 숨김) 에 사용한다.</p>
+     *
+     * @returns {'granted'|'denied'|'default'|'unsupported'}
+     */
+    TalkFlowClient.prototype.getPushPermissionState = function getPushPermissionState() {
+        return PushManager.getPermissionState();
+    };
+
+    /**
+     * SDK 내부 푸시 활성화 상태 (FCM 토큰 발급 + 서버 등록까지 완료 여부).
+     *
+     * <p>주의: 이 값은 SDK 인스턴스의 메모리 상태일 뿐, 브라우저 권한 상태와 다르다.
+     * 페이지 새로고침 후에는 enable 호출 전까지 false. 권한 상태는 {@link #getPushPermissionState} 사용.</p>
+     *
+     * @returns {boolean}
+     */
+    TalkFlowClient.prototype.isPushEnabled = function isPushEnabled() {
+        return this.pushManager?.isEnabled() ?? false;
+    };
+
+    /**
+     * 현재 발급된 FCM 토큰. enable 호출 후에만 유효, 그 외에는 null.
+     * @returns {string|null}
+     */
+    TalkFlowClient.prototype.getPushToken = function getPushToken() {
+        return this.pushManager?.getToken() ?? null;
+    };
+
+    /**
+     * 푸시 상태 초기화 — 포그라운드 리스너 / FCM 토큰 / SW projectId 등록을 해제한다.
+     * 로그아웃 또는 사용자 전환 시 호출. (logout() 내부에서도 자동 호출되므로 일반 흐름에선 불필요.)
+     */
+    TalkFlowClient.prototype.resetPush = function resetPush() {
+        this.pushManager?.reset();
+        this._pushEnablePromise = null;
+    };
+
+    TalkFlowClient.prototype.setToken = async function setToken(token) {
+        const { userId } = validateAndParseJWT(token, { validateExpiry: false });
+        const needReinitialize = this.userId && this.userId !== userId;
+
+        this.options.jwtToken = token;
+        this._userId = userId;
+        this.apiClient.setJwtToken(token);
+
+        if (needReinitialize && this.connectionManager) {
+            await this.disconnect();
+            if (this.pushManager) {
+                this.pushManager.reset();
+                this._pushEnablePromise = null;
+            }
+            this.connectionManager = null;
+            this._chat = null;
+            this._webrtc = null;
+
+            this._initializeSubClients();
+        } else if (this.connectionManager) {
+            this.connectionManager.updateToken(token);
+        } else {
+            this._initializeSubClients();
+        }
+
+        this.logger.info('JWT token set', { userId });
+        this.emit('tokenSet', { userId });
+    };
+
+    TalkFlowClient.prototype.updateToken = async function updateToken(newToken) {
+        await this.setToken(newToken);
+    };
+}