@vibexnpm/talkx 8.5.0 → 8.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@vibexnpm/talkx",
-    "version": "8.5.0",
+    "version": "8.7.0",
     "type": "module",
     "description": "TalkFlow SDK - Chat & WebRTC unified client",
     "main": "dist/talkflow-sdk.umd.js",

package/src/TalkFlowClient.js

@@ -39,6 +39,7 @@ class TalkFlowClient extends EventEmitter {
      * // 1단계: 로그인 — 클라이언트 생성 «전» 에 부른다. ck/projectId/JWT 를 한 번에 받는다.
      * //   const { clientKey, projectId, accessToken } = await TalkFlowClient.loginUser({
      * //       serverUrl, email, password });
+     * //   (회사 계정이 둘 이상이면 먼저 workspaceSelectionRequired 결과 → projectId 를 실어 다시 부른다)
      *
      * // 2단계: 받은 값으로 SDK 초기화
      * const client = new TalkFlowClient({
@@ -72,6 +73,7 @@ class TalkFlowClient extends EventEmitter {
             reconnectDelay: options.reconnectDelay || DefaultConfig.reconnectDelay,
             maxReconnectDelay: options.maxReconnectDelay || DefaultConfig.maxReconnectDelay,
             maxReconnectAttempts: options.maxReconnectAttempts || DefaultConfig.maxReconnectAttempts,
+            reconnectRecoveryDelay: options.reconnectRecoveryDelay ?? DefaultConfig.reconnectRecoveryDelay,
             heartbeatIncoming: options.heartbeatIncoming || DefaultConfig.heartbeatIncoming,
             heartbeatOutgoing: options.heartbeatOutgoing || DefaultConfig.heartbeatOutgoing,
             // 탭 복귀 / 네트워크 복구 시 자동 재연결. false 로 꺼야 하므로 !== false 로 보존 —
@@ -309,21 +311,28 @@ class TalkFlowClient extends EventEmitter {
      * <p>Server Key 도 고객사 BFF 도 필요 없다. 응답의
      * {@code clientKey}/{@code projectId}/{@code accessToken} 이 그대로 SDK 초기화 입력이다.</p>
      *
-     * <p><b>회사 선택 단계가 없다</b>: 로그인 키가 전역 유일이라 이메일 하나로 회원과 회사가
-     * 함께 정해진다. 퇴사하면 그 키가 풀려 다른 회사에서 같은 이메일을 다시 쓸 수 있다.</p>
+     * <p><b>회사 선택</b>: 같은 이메일이 여러 회사에 계정을 가질 수 있다(다른 회사의 게스트 등). 비밀번호가 맞는 계정이
+     * 둘 이상이면 토큰 없이 {@code {workspaceSelectionRequired: true, workspaces: [{projectId, companyName, companyRole}]}}
+     * 를 돌려준다 — 저장된 세션은 그대로다. 고른 {@code projectId} 를 실어 같은 이메일·비밀번호로 다시 부른다.
+     * 계정이 하나면 지금처럼 바로 로그인된다.</p>
      *
      * @param {Object} options
      * @param {string} options.serverUrl - 채팅 서버 base URL
      * @param {string} options.email
      * @param {string} options.password
-     * @returns {Promise<Object>} `{accessToken, tokenType, expiresIn, projectId, clientKey, user}`
+     * @param {string} [options.projectId] - 회사 선택 응답에서 고른 회사
+     * @returns {Promise<Object>} `{accessToken, tokenType, expiresIn, projectId, clientKey, user}` 또는 회사 선택 결과
      *
      * @example
-     * const login = await TalkFlowClient.loginUser({
+     * let login = await TalkFlowClient.loginUser({
      *     serverUrl: 'https://chat.apiorbit.net',
      *     email: 'dan@example.com',
      *     password: '********'
      * });
+     * if (login.workspaceSelectionRequired) {
+     *     const picked = await showWorkspacePicker(login.workspaces);   // 화면에서 고른 회사
+     *     login = await TalkFlowClient.loginUser({ serverUrl, email, password, projectId: picked.projectId });
+     * }
      *
      * const client = new TalkFlowClient({
      *     apiKey: login.clientKey,
@@ -332,13 +341,13 @@ class TalkFlowClient extends EventEmitter {
      * });
      * await client.connect();
      */
-    static async loginUser({ serverUrl, email, password }) {
+    static async loginUser({ serverUrl, email, password, projectId }) {
         if (!serverUrl) throw new Error('serverUrl is required');
         if (!email) throw new Error('email is required');
         if (!password) throw new Error('password is required');
 
         // 로그인은 키를 «받기 위해» 부르는 경로라 X-API-KEY/X-PROJECT-ID 가 없다(서버에서 필터 제외).
-        return AuthSession.forServer(serverUrl).login({ email, password });
+        return AuthSession.forServer(serverUrl).login({ email, password, projectId });
     }
 
     /**
@@ -347,16 +356,19 @@ class TalkFlowClient extends EventEmitter {
      * <p>이미 클라이언트가 있는 상태의 재로그인·계정 전환용이다. 최초 진입은 클라이언트 생성 전에
      * 부르는 정적 {@link TalkFlowClient.loginUser} 를 쓴다 — 그쪽이 {@code clientKey} 까지 준다.</p>
      *
+     * <p>회사 선택 응답이면 토큰을 설정하지 않고 그 결과를 돌려준다 — 정적 {@link TalkFlowClient.loginUser} 와 같다.</p>
+     *
      * @param {Object} credentials
      * @param {string} credentials.email
      * @param {string} credentials.password
-     * @returns {Promise<Object>} 로그인 응답
+     * @param {string} [credentials.projectId] - 회사 선택 응답에서 고른 회사
+     * @returns {Promise<Object>} 로그인 응답 또는 회사 선택 결과
      */
-    async loginUser({ email, password }) {
+    async loginUser({ email, password, projectId }) {
         if (!email || !password) throw new Error('email and password are required');
         this._enableRefreshSession();
         await this._authReady;
-        return this.authSession.login({ email, password });
+        return this.authSession.login({ email, password, projectId });
     }
 
     /**

package/src/auth/AuthSession.js

@@ -4,6 +4,21 @@ const sessions = new Map();
 const TERMINAL_CODES = new Set(['REFRESH_INVALID', 'REFRESH_REUSED', 'SESSION_REVOKED', 'ACCOUNT_BLOCKED', 'LOGIN_FAILED']);
 export const isTerminalAuthError = error => TERMINAL_CODES.has(error?.response?.code || error?.code);
 
+/**
+ * 로그인 회사 선택 결과 — 토큰이 없다. 목록이 비었거나 회사 id 가 없는 응답은 계약 위반이라 인증 불가로 끊는다(빈 선택 화면을 띄우지 않게).
+ */
+function workspaceSelection(data) {
+    const workspaces = Array.isArray(data.workspaces) ? data.workspaces : [];
+    if (workspaces.length === 0 || workspaces.some(workspace => !workspace?.projectId)) {
+        const error = new Error('Invalid authentication response'); error.code = 'AUTH_UNAVAILABLE'; throw error;
+    }
+    return {
+        workspaceSelectionRequired: true,
+        workspaces: workspaces.map(({ projectId, companyName, companyRole }) =>
+            ({ projectId, companyName: companyName ?? null, companyRole }))
+    };
+}
+
 export function tokenClaims(token) {
     try {
         const value = token.replace(/^Bearer\s+/i, '').split('.')[1].replace(/-/g, '+').replace(/_/g, '/');
@@ -240,13 +255,23 @@ export default class AuthSession extends EventEmitter {
         } finally { clearTimeout(timeout); }
     }
 
-    async login({ email, password }) {
+    /**
+     * 같은 이메일로 여러 회사 계정이 있고 비밀번호가 둘 이상 맞으면 서버는 토큰 없이 회사 목록만 준다. 그 응답은
+     * {@link workspaceSelection} 결과로 돌려준다. 저장소·인증 상태·이전 세션은 건드리지 않는다 — 서버도 이 단계에서는
+     * 이전 세션을 끊지 않는다. 호출자는 고른 {@code projectId} 를 실어 같은 자격으로 다시 부른다(서버가 비밀번호를 다시 검증).
+     */
+    async login({ email, password, projectId }) {
         const generation = ++this.generation;
         return this._locked(async () => {
             const previous = this._readMarker();
             this._writeMarker(previous);
             if (previous.pendingRefreshToken) await this._request('/v1/auth/signout', { refreshToken: previous.pendingRefreshToken, deviceId: previous.deviceId });
-            const data = await this._request('/api/v1/auth/login', { email, password, previousRefreshToken: previous.refreshToken });
+            const data = await this._request('/api/v1/auth/login',
+                { email, password, previousRefreshToken: previous.refreshToken, ...(projectId ? { projectId } : {}) });
+            if (data?.workspaceSelectionRequired === true) {
+                if (generation !== this.generation) throw this._cancelled();
+                return workspaceSelection(data);
+            }
             if (!data?.refreshToken) {
                 const error = new Error('Server does not support the refresh session contract');
                 error.code = 'AUTH_PROTOCOL_UNSUPPORTED';

package/src/chat/ChatClient.js

@@ -7,7 +7,7 @@
 
 import EventEmitter from '../utils/EventEmitter.js';
 import Logger from '../utils/Logger.js';
-import { WebSocketPaths, LogLevel, RoomListEventType, ChatRoomType, DefaultConfig } from '../constants.js';
+import { WebSocketPaths, LogLevel, RoomListEventType, ChatRoomType, DefaultConfig, ConnectionState } from '../constants.js';
 
 const MAX_FILES_PER_MESSAGE = 20;
 
@@ -186,6 +186,8 @@ class ChatClient extends EventEmitter {
         // 상수로 두면 maxSyncPages 튜닝 시 조용히 어긋나므로 config 에서 파생시킨다 (설계 §7).
         this._maxSeenPerRoom = Math.max(200, this.maxSyncPages * this.syncPageSize + 100);
 
+        this._reconnectSyncGeneration = 0;
+        this._delayedReconnectSyncTimer = null;
         this._installSyncTriggers();
     }
 
@@ -205,8 +207,20 @@ class ChatClient extends EventEmitter {
         // syncOnReconnect 옵션 + anchor 있는 방이라는 두 겹 필터가 걸려 있어서, 거기 얹으면 옵션이
         // 꺼져 있거나 그 방에서 메시지를 받은 적이 없을 때 replay 가 조용히 빠진다.
         this._onReconnectedForSync = ({ attempts } = {}) => {
+            this._cancelDelayedReconnectSync();
+            const generation = this._reconnectSyncGeneration;
             this.syncAfterReconnect(`reconnected:${attempts ?? 0}`)
-                .catch((error) => this.logger.warn('Gap sync after reconnect failed:', error));
+                .catch((error) => this.logger.warn('Gap sync after reconnect failed:', error))
+                .then((cursors) => {
+                    if (!this.syncOnReconnect || !cursors || generation !== this._reconnectSyncGeneration) return;
+                    // SUBSCRIBE 전송과 SimpleBroker 등록은 다른 시점이다. 첫 snapshot 뒤의 공백을 다시 읽는다.
+                    this._delayedReconnectSyncTimer = setTimeout(() => {
+                        this._delayedReconnectSyncTimer = null;
+                        this._supplementAfterReconnect(cursors, generation)
+                            .catch(error => this.logger.warn('Delayed gap sync failed:', error));
+                    }, 1000);
+                    this._delayedReconnectSyncTimer.unref?.();
+                });
             this.resumeAssistantStreams(`reconnected:${attempts ?? 0}`)
                 .catch((error) => this.logger.warn('Assistant stream replay after reconnect failed:', error));
         };
@@ -217,6 +231,10 @@ class ChatClient extends EventEmitter {
                 .catch((error) => this.logger.warn('Assistant stream replay after resume failed:', error));
         };
 
+        this._onStateChangeForSync = ({ state }) => {
+            if (state !== ConnectionState.CONNECTED) this._cancelDelayedReconnectSync();
+        };
+        this.connectionManager.on('stateChange', this._onStateChangeForSync);
         this.connectionManager.on('reconnected', this._onReconnectedForSync);
         this.connectionManager.on('resumed', this._onResumedForSync);
     }
@@ -1596,8 +1614,7 @@ class ChatClient extends EventEmitter {
      * @private
      * @returns {Promise<Object|null>} 복구 결과. 대상이 아니면 null.
      */
-    async _syncRoom(roomId) {
-        const anchor = this._anchor.get(roomId);
+    async _syncRoom(roomId, anchor = this._anchor.get(roomId), quiet = false) {
         // 이 세션에서 아직 받은 메시지가 없는 방 — enterRoom 의 초기 로드가 담당한다.
         if (!anchor) return null;
         if (this._syncInFlight.has(roomId)) return null;
@@ -1631,25 +1648,25 @@ class ChatClient extends EventEmitter {
             if (hasMore) {
                 // 상한 초과 — 버퍼를 통째로 버리고 최신 페이지로 전환한다(부분 replay 금지).
                 this.logger.info(`Gap too large, falling back to latest page: room=${roomId}`);
-                this.emit('gapTruncated', { roomId, fetched: buffer.length });
+                if (!quiet) this.emit('gapTruncated', { roomId, fetched: buffer.length });
                 const reloaded = await this._reloadLatestPage(roomId, genAtStart);
                 return {
-                    roomId, recovered: reloaded, truncated: true, durationMs: Date.now() - startedAt
+                    roomId, cursor: this._anchor.get(roomId), recovered: reloaded, truncated: true, durationMs: Date.now() - startedAt
                 };
             }
 
             const recovered = this._replayMessages(roomId, buffer);
             this._commitAnchorFromSync(roomId, cursor, genAtStart);
-            return { roomId, recovered, truncated: false, durationMs: Date.now() - startedAt };
+            return { roomId, cursor, recovered, truncated: false, durationMs: Date.now() - startedAt };
 
         } catch (error) {
             if (this._isCursorExpired(error)) {
                 // retention 정리 등으로 앵커가 사라짐 — 최신 페이지로 복구한다.
                 this.logger.warn(`Sync cursor expired, reloading latest: room=${roomId}`);
-                this.emit('gapTruncated', { roomId, fetched: 0, reason: 'cursorExpired' });
+                if (!quiet) this.emit('gapTruncated', { roomId, fetched: 0, reason: 'cursorExpired' });
                 const reloaded = await this._reloadLatestPage(roomId, genAtStart);
                 return {
-                    roomId, recovered: reloaded, truncated: true, durationMs: Date.now() - startedAt
+                    roomId, cursor: this._anchor.get(roomId), recovered: reloaded, truncated: true, durationMs: Date.now() - startedAt
                 };
             }
             throw error;
@@ -1665,7 +1682,7 @@ class ChatClient extends EventEmitter {
      * 상호 배타적이라 중복 실행되지 않는다.</p>
      *
      * @param {string} [reason]
-     * @returns {Promise<void>}
+     * @returns {Promise<Map<string, string>|undefined>} 1차 조회 cursor — 내부 보충 조회용.
      */
     async syncAfterReconnect(reason = 'manual') {
         if (!this.syncOnReconnect) return;
@@ -1679,11 +1696,15 @@ class ChatClient extends EventEmitter {
         this.emit('syncStarted', { roomIds, reason });
         const startedAt = Date.now();
         const rooms = [];
+        const cursors = new Map();
 
         for (const roomId of roomIds) {
             try {
                 const result = await this._syncRoom(roomId);
-                if (result) rooms.push(result);
+                if (result) {
+                    rooms.push(result);
+                    cursors.set(roomId, result.cursor);
+                }
             } catch (error) {
                 // 한 방의 실패가 나머지 방 복구를 막지 않게 한다.
                 this.logger.warn(`Gap sync failed: room=${roomId}`, error);
@@ -1698,6 +1719,17 @@ class ChatClient extends EventEmitter {
             durationMs: Date.now() - startedAt,
             reason
         });
+        return cursors;
+    }
+
+    /** 첫 조회가 끝난 cursor부터 조용히 보충한다. 목록·동기화 이벤트는 첫 조회의 책임이다. */
+    async _supplementAfterReconnect(cursors, generation) {
+        for (const [roomId, cursor] of cursors) {
+            if (generation !== this._reconnectSyncGeneration) return;
+            if (!this.subscribedRooms.has(roomId)) continue;
+            try { await this._syncRoom(roomId, cursor, true); }
+            catch (error) { this.logger.warn(`Supplemental gap sync failed: room=${roomId}`, error); }
+        }
     }
 
     /**
@@ -2479,8 +2511,8 @@ class ChatClient extends EventEmitter {
      * @param {string} roomId - 채팅방 ID
      * @returns {Promise<void>}
      *
-     * @fires memberJoined - { roomId, members: [{ userId, nickname, profileUrl }], participantCount, timestamp }
-     * @fires memberLeft   - { roomId, members: [{ userId, nickname, profileUrl }], participantCount, timestamp }
+     * @fires memberJoined - { roomId, members: [{ userId, nickname, profileUrl, companyRole? }], participantCount, timestamp }
+     * @fires memberLeft   - { roomId, members: [{ userId, nickname, profileUrl, companyRole? }], participantCount, timestamp }
      */
     async subscribeRoom(roomId) {
         if (this.subscribedRooms.has(roomId)) {
@@ -3864,13 +3896,16 @@ class ChatClient extends EventEmitter {
         this.logger.setLevel(level);
     }
 
-    /**
-     * 리소스 정리.
-     *
-     * <p>{@link #unsubscribeRoom} 에서 방별 타이머를 정리하지만, 구독 목록에 없는
-     * roomId 의 debounce 타이머가 남아 있을 수 있어 Map 전체를 명시적으로 비운다.</p>
-     */
+    _cancelDelayedReconnectSync() {
+        this._reconnectSyncGeneration++;
+        clearTimeout(this._delayedReconnectSyncTimer);
+        this._delayedReconnectSyncTimer = null;
+    }
+
+    /** 구독, 예약된 복구, 방별 진행 표시를 정리한다. */
     destroy() {
+        this._cancelDelayedReconnectSync();
+        this.connectionManager.off?.('stateChange', this._onStateChangeForSync);
         this.unsubscribeAllRooms();
         if (this.roomListSubscribed) {
             this.unsubscribeRoomList();

package/src/constants.js

@@ -438,6 +438,7 @@ export const DefaultConfig = {
     // 지수 백오프 상한 — 서버 재시작 시 전 클라이언트가 고정 간격으로 몰리는 것을 완화.
     maxReconnectDelay: 30000,
     maxReconnectAttempts: 10,
+    reconnectRecoveryDelay: 60000,
     heartbeatIncoming: 10000,
     heartbeatOutgoing: 10000,