@vibexnpm/talkx 2.3.1

package/src/utils/jwtUtils.js

@@ -0,0 +1,213 @@
+/**
+ * JWT 유틸리티 함수
+ * JWT 토큰 파싱 및 검증
+ */
+
+import { ErrorTypes } from '../constants.js';
+
+/**
+ * Bearer 접두사 제거
+ * @param {string} token - JWT 토큰
+ * @returns {string}
+ */
+function stripBearer(token) {
+    if (!token || typeof token !== 'string') {
+        return '';
+    }
+    return token.replace(/^Bearer\s+/i, '');
+}
+
+/**
+ * Base64URL 디코딩 (UTF-8 안전)
+ * @param {string} str - Base64URL 인코딩된 문자열
+ * @returns {string}
+ */
+function base64UrlDecode(str) {
+    let base64 = str.replace(/-/g, '+').replace(/_/g, '/');
+    const padding = base64.length % 4;
+    if (padding) {
+        base64 += '='.repeat(4 - padding);
+    }
+    // atob()은 Latin-1 기반이라 멀티바이트 UTF-8(한국어 등)이 깨짐
+    // → Uint8Array 변환 후 TextDecoder로 UTF-8 디코딩
+    const binaryString = atob(base64);
+    const bytes = Uint8Array.from(binaryString, c => c.charCodeAt(0));
+    return new TextDecoder().decode(bytes);
+}
+
+/**
+ * JWT 토큰 검증 및 파싱
+ * @param {string} jwtToken - JWT 토큰 (Bearer 접두사 포함 가능)
+ * @param {Object} [options] - 옵션
+ * @param {number} [options.bufferSeconds=30] - 만료 버퍼 시간 (초)
+ * @param {boolean} [options.validateExpiry=true] - 만료 시간 검증 여부
+ * @returns {{userId: string, payload: Object}}
+ * @throws {Error}
+ */
+export function validateAndParseJWT(jwtToken, options = {}) {
+    const { bufferSeconds = 30, validateExpiry = true } = options;
+
+    if (!jwtToken || typeof jwtToken !== 'string') {
+        const error = new Error('JWT token is required');
+        error.code = ErrorTypes.JWT_INVALID;
+        throw error;
+    }
+
+    const tokenWithoutBearer = stripBearer(jwtToken);
+    const parts = tokenWithoutBearer.split('.');
+
+    if (parts.length !== 3) {
+        const error = new Error('Invalid JWT format: expected 3 parts separated by dots');
+        error.code = ErrorTypes.JWT_INVALID;
+        throw error;
+    }
+
+    let payload;
+    try {
+        payload = JSON.parse(base64UrlDecode(parts[1]));
+    } catch (e) {
+        const error = new Error('Invalid JWT: failed to decode payload');
+        error.code = ErrorTypes.JWT_PARSE_FAILED;
+        error.originalError = e;
+        throw error;
+    }
+
+    if (validateExpiry && payload.exp) {
+        const expiryTime = payload.exp * 1000;
+        const bufferTime = bufferSeconds * 1000;
+        const now = Date.now();
+
+        if (expiryTime < now + bufferTime) {
+            const error = new Error(
+                expiryTime < now
+                    ? 'JWT token expired'
+                    : `JWT token expires within ${bufferSeconds} seconds`
+            );
+            error.code = ErrorTypes.JWT_EXPIRED;
+            error.expiredAt = new Date(expiryTime).toISOString();
+            throw error;
+        }
+    }
+
+    if (payload.iat) {
+        const issuedAt = payload.iat * 1000;
+        const clockSkew = 60 * 1000;
+
+        if (issuedAt > Date.now() + clockSkew) {
+            const error = new Error('JWT token issued in the future');
+            error.code = ErrorTypes.JWT_INVALID;
+            throw error;
+        }
+    }
+
+    const userId = payload.userId || payload.sub || payload.user_id;
+
+    if (!userId) {
+        const error = new Error('Cannot extract userId from JWT: missing userId, sub, or user_id claim');
+        error.code = ErrorTypes.JWT_INVALID;
+        throw error;
+    }
+
+    return { userId, payload };
+}
+
+/**
+ * JWT에서 userId만 추출
+ * @param {string} jwtToken - JWT 토큰
+ * @returns {string|null}
+ */
+export function extractUserIdFromJWT(jwtToken) {
+    try {
+        const tokenWithoutBearer = stripBearer(jwtToken);
+        const parts = tokenWithoutBearer.split('.');
+
+        if (parts.length !== 3) {
+            return null;
+        }
+
+        const payload = JSON.parse(base64UrlDecode(parts[1]));
+        return payload.userId || payload.sub || payload.user_id || null;
+    } catch (error) {
+        console.error('Failed to extract userId from JWT:', error);
+        return null;
+    }
+}
+
+/**
+ * JWT 만료 여부 확인
+ * @param {string} jwtToken - JWT 토큰
+ * @param {number} [bufferSeconds=0] - 버퍼 시간 (초)
+ * @returns {boolean}
+ */
+export function isJWTExpired(jwtToken, bufferSeconds = 0) {
+    try {
+        const tokenWithoutBearer = stripBearer(jwtToken);
+        const parts = tokenWithoutBearer.split('.');
+
+        if (parts.length !== 3) {
+            return true;
+        }
+
+        const payload = JSON.parse(base64UrlDecode(parts[1]));
+
+        if (!payload.exp) {
+            return false;
+        }
+
+        const expiryTime = payload.exp * 1000;
+        const bufferTime = bufferSeconds * 1000;
+
+        return expiryTime < Date.now() + bufferTime;
+    } catch (error) {
+        console.error('Failed to check JWT expiration:', error);
+        return true;
+    }
+}
+
+/**
+ * JWT 남은 유효 시간 반환
+ * @param {string} jwtToken - JWT 토큰
+ * @returns {number} - 밀리초, 만료 시 음수
+ */
+export function getJWTRemainingTime(jwtToken) {
+    try {
+        const tokenWithoutBearer = stripBearer(jwtToken);
+        const parts = tokenWithoutBearer.split('.');
+
+        if (parts.length !== 3) {
+            return -1;
+        }
+
+        const payload = JSON.parse(base64UrlDecode(parts[1]));
+
+        if (!payload.exp) {
+            return Infinity;
+        }
+
+        return (payload.exp * 1000) - Date.now();
+    } catch (error) {
+        console.error('Failed to get JWT remaining time:', error);
+        return -1;
+    }
+}
+
+/**
+ * JWT payload 디코딩 (검증 없이)
+ * @param {string} jwtToken - JWT 토큰
+ * @returns {Object|null}
+ */
+export function decodeJWTPayload(jwtToken) {
+    try {
+        const tokenWithoutBearer = stripBearer(jwtToken);
+        const parts = tokenWithoutBearer.split('.');
+
+        if (parts.length !== 3) {
+            return null;
+        }
+
+        return JSON.parse(base64UrlDecode(parts[1]));
+    } catch (error) {
+        console.error('Failed to decode JWT payload:', error);
+        return null;
+    }
+}

package/src/webrtc/MediaStreamManager.js

@@ -0,0 +1,478 @@
+/**
+ * MediaStreamManager
+ * 로컬 미디어 스트림 관리 (카메라/마이크/화면공유)
+ */
+
+import EventEmitter from '../utils/EventEmitter.js';
+import Logger from '../utils/Logger.js';
+import { ErrorTypes, LogLevel } from '../constants.js';
+
+class MediaStreamManager extends EventEmitter {
+    /**
+     * @param {Object} options
+     * @param {number} [options.logLevel] - 로그 레벨
+     */
+    constructor(options = {}) {
+        super();
+
+        this.localStream = null;
+        this.screenStream = null;
+        this.videoEnabled = true;
+        this.audioEnabled = true;
+
+        this.logger = new Logger(options.logLevel || LogLevel.WARN, 'MediaStreamManager');
+        this._deviceChangeHandler = null;
+    }
+
+    /**
+     * 사용자 미디어 가져오기
+     * @param {Object} constraints - 미디어 제약조건
+     * @returns {Promise<MediaStream>}
+     */
+    async getUserMedia(constraints = { video: true, audio: true }) {
+        try {
+            this.localStream = await navigator.mediaDevices.getUserMedia(constraints);
+            this.videoEnabled = constraints.video !== false;
+            this.audioEnabled = constraints.audio !== false;
+
+            this.emit('streamStarted', { stream: this.localStream });
+            this.logger.info('User media stream started');
+            return this.localStream;
+        } catch (error) {
+            this.logger.error('Failed to get user media:', error);
+            this.emit('error', {
+                type: ErrorTypes.MEDIA_ACCESS_DENIED,
+                message: this._getMediaErrorMessage(error),
+                error
+            });
+            throw error;
+        }
+    }
+
+    /**
+     * 미디어 에러 메시지 변환
+     * @private
+     * @param {Error} error - 에러 객체
+     * @returns {string} 변환된 에러 메시지
+     */
+    _getMediaErrorMessage(error) {
+        switch (error.name) {
+            case 'NotAllowedError':
+                return 'Camera/Microphone permission denied';
+            case 'NotFoundError':
+                return 'Camera/Microphone not found';
+            case 'NotReadableError':
+                return 'Camera/Microphone is already in use';
+            case 'OverconstrainedError':
+                return 'Camera/Microphone constraints cannot be satisfied';
+            case 'AbortError':
+                return 'Media access aborted';
+            default:
+                return error.message || 'Unknown media error';
+        }
+    }
+
+    /**
+     * 화면 공유 가져오기
+     * @param {Object} [options] - 화면 공유 옵션
+     * @returns {Promise<MediaStream>}
+     */
+    async getDisplayMedia(options = { video: true, audio: false }) {
+        try {
+            this.screenStream = await navigator.mediaDevices.getDisplayMedia(options);
+
+            // 화면 공유 종료 감지
+            this.screenStream.getVideoTracks()[0].onended = () => {
+                this.emit('screenShareEnded', {});
+                this.screenStream = null;
+            };
+
+            this.emit('screenShareStarted', { stream: this.screenStream });
+            this.logger.info('Screen share stream started');
+            return this.screenStream;
+        } catch (error) {
+            this.logger.error('Failed to get display media:', error);
+            this.emit('error', {
+                type: ErrorTypes.SCREEN_SHARE_DENIED,
+                message: error.name === 'NotAllowedError'
+                    ? 'Screen share permission denied'
+                    : error.message,
+                error
+            });
+            throw error;
+        }
+    }
+
+    /**
+     * 비디오 토글
+     * @returns {boolean} 현재 상태
+     */
+    toggleVideo() {
+        if (!this.localStream) {
+            this.logger.warn('No local stream available');
+            return this.videoEnabled;
+        }
+
+        const videoTracks = this.localStream.getVideoTracks();
+        if (videoTracks.length === 0) {
+            this.logger.warn('No video track available');
+            return this.videoEnabled;
+        }
+
+        this.videoEnabled = !this.videoEnabled;
+        videoTracks.forEach(track => {
+            track.enabled = this.videoEnabled;
+        });
+
+        this.emit('videoToggled', { enabled: this.videoEnabled });
+        this.logger.debug(`Video toggled: ${this.videoEnabled}`);
+        return this.videoEnabled;
+    }
+
+    /**
+     * 오디오 토글
+     * @returns {boolean} 현재 상태
+     */
+    toggleAudio() {
+        if (!this.localStream) {
+            this.logger.warn('No local stream available');
+            return this.audioEnabled;
+        }
+
+        const audioTracks = this.localStream.getAudioTracks();
+        if (audioTracks.length === 0) {
+            this.logger.warn('No audio track available');
+            return this.audioEnabled;
+        }
+
+        this.audioEnabled = !this.audioEnabled;
+        audioTracks.forEach(track => {
+            track.enabled = this.audioEnabled;
+        });
+
+        this.emit('audioToggled', { enabled: this.audioEnabled });
+        this.logger.debug(`Audio toggled: ${this.audioEnabled}`);
+        return this.audioEnabled;
+    }
+
+    /**
+     * 비디오 상태 설정
+     * @param {boolean} enabled
+     */
+    setVideoEnabled(enabled) {
+        if (!this.localStream) {
+            this.logger.warn('No local stream available');
+            return;
+        }
+
+        const videoTracks = this.localStream.getVideoTracks();
+        videoTracks.forEach(track => {
+            track.enabled = enabled;
+        });
+        this.videoEnabled = enabled;
+        this.emit('videoToggled', { enabled });
+    }
+
+    /**
+     * 오디오 상태 설정
+     * @param {boolean} enabled
+     */
+    setAudioEnabled(enabled) {
+        if (!this.localStream) {
+            this.logger.warn('No local stream available');
+            return;
+        }
+
+        const audioTracks = this.localStream.getAudioTracks();
+        audioTracks.forEach(track => {
+            track.enabled = enabled;
+        });
+        this.audioEnabled = enabled;
+        this.emit('audioToggled', { enabled });
+    }
+
+    /**
+     * 로컬 스트림 가져오기
+     * @returns {MediaStream|null}
+     */
+    getLocalStream() {
+        return this.localStream;
+    }
+
+    /**
+     * 화면 공유 스트림 가져오기
+     * @returns {MediaStream|null}
+     */
+    getScreenStream() {
+        return this.screenStream;
+    }
+
+    /**
+     * 현재 비디오 상태
+     * @returns {boolean}
+     */
+    isVideoEnabled() {
+        return this.videoEnabled;
+    }
+
+    /**
+     * 현재 오디오 상태
+     * @returns {boolean}
+     */
+    isAudioEnabled() {
+        return this.audioEnabled;
+    }
+
+    /**
+     * 모든 트랙 중지
+     */
+    stopAll() {
+        if (this.localStream) {
+            this.localStream.getTracks().forEach(track => track.stop());
+            this.localStream = null;
+            this.emit('streamStopped', {});
+            this.logger.info('All media tracks stopped');
+        }
+
+        if (this.screenStream) {
+            this.screenStream.getTracks().forEach(track => track.stop());
+            this.screenStream = null;
+        }
+    }
+
+    /**
+     * 특정 트랙 교체 (내부용 - switchDevice에서 호출)
+     * @private
+     * @param {MediaStreamTrack} oldTrack
+     * @param {MediaStreamTrack} newTrack
+     */
+    replaceTrack(oldTrack, newTrack) {
+        if (!this.localStream) {
+            this.logger.warn('No local stream available');
+            return;
+        }
+
+        this.localStream.removeTrack(oldTrack);
+        this.localStream.addTrack(newTrack);
+        oldTrack.stop();
+
+        this.emit('trackReplaced', { oldTrack, newTrack });
+        this.logger.debug(`Track replaced: ${oldTrack.kind}`);
+    }
+
+    /**
+     * 특정 종류의 트랙 가져오기
+     * @param {string} kind - 'video' or 'audio'
+     * @returns {MediaStreamTrack|null}
+     */
+    getTrack(kind) {
+        if (!this.localStream) return null;
+
+        const tracks = kind === 'video'
+            ? this.localStream.getVideoTracks()
+            : this.localStream.getAudioTracks();
+
+        return tracks.length > 0 ? tracks[0] : null;
+    }
+
+    /**
+     * 디바이스 목록 가져오기
+     * @returns {Promise<Object>}
+     */
+    async getDevices() {
+        try {
+            const devices = await navigator.mediaDevices.enumerateDevices();
+
+            return {
+                videoInputs: devices.filter(d => d.kind === 'videoinput'),
+                audioInputs: devices.filter(d => d.kind === 'audioinput'),
+                audioOutputs: devices.filter(d => d.kind === 'audiooutput')
+            };
+        } catch (error) {
+            this.logger.error('Failed to enumerate devices:', error);
+            this.emit('error', {
+                type: ErrorTypes.ENUMERATE_DEVICES_FAILED,
+                message: error.message,
+                error
+            });
+            throw error;
+        }
+    }
+
+    /**
+     * 특정 디바이스로 전환
+     * @param {string} deviceId - 디바이스 ID
+     * @param {string} kind - 'video' or 'audio'
+     * @returns {Promise<MediaStreamTrack>}
+     * @throws {Error} 스트림이 없거나 디바이스 전환 실패 시
+     */
+    async switchDevice(deviceId, kind) {
+        if (!this.localStream) {
+            throw new Error('No local stream available');
+        }
+
+        try {
+            const constraints = kind === 'video'
+                ? { video: { deviceId: { exact: deviceId } }, audio: false }
+                : { video: false, audio: { deviceId: { exact: deviceId } } };
+
+            const newStream = await navigator.mediaDevices.getUserMedia(constraints);
+            const newTrack = newStream.getTracks()[0];
+
+            const oldTrack = kind === 'video'
+                ? this.localStream.getVideoTracks()[0]
+                : this.localStream.getAudioTracks()[0];
+
+            if (oldTrack) {
+                this.replaceTrack(oldTrack, newTrack);
+
+                this.emit('deviceSwitched', {
+                    kind,
+                    deviceId,
+                    newTrack
+                });
+
+                this.logger.info(`${kind} device switched to ${deviceId}`);
+            }
+
+            return newTrack;
+
+        } catch (error) {
+            this.logger.error(`Failed to switch ${kind} device:`, error);
+            this.emit('error', {
+                type: ErrorTypes.DEVICE_SWITCH_FAILED,
+                message: error.message,
+                error
+            });
+            throw error;
+        }
+    }
+
+    /**
+     * 디바이스 변경 감지 시작
+     */
+    startDeviceChangeDetection() {
+        if (this._deviceChangeHandler) {
+            return;
+        }
+
+        this._deviceChangeHandler = async () => {
+            try {
+                const devices = await this.getDevices();
+                this.emit('deviceChange', devices);
+                this.logger.debug('Device change detected');
+            } catch (error) {
+                this.logger.warn('Failed to get devices on change:', error);
+            }
+        };
+
+        navigator.mediaDevices.addEventListener('devicechange', this._deviceChangeHandler);
+        this.logger.debug('Device change detection started');
+    }
+
+    /**
+     * 디바이스 변경 감지 중지
+     */
+    stopDeviceChangeDetection() {
+        if (this._deviceChangeHandler) {
+            navigator.mediaDevices.removeEventListener('devicechange', this._deviceChangeHandler);
+            this._deviceChangeHandler = null;
+            this.logger.debug('Device change detection stopped');
+        }
+    }
+
+    /**
+     * 스트림 정보
+     * @returns {Object}
+     */
+    getStreamInfo() {
+        if (!this.localStream) {
+            return {
+                hasStream: false,
+                videoEnabled: this.videoEnabled,
+                audioEnabled: this.audioEnabled,
+                tracks: []
+            };
+        }
+
+        return {
+            hasStream: true,
+            videoEnabled: this.videoEnabled,
+            audioEnabled: this.audioEnabled,
+            tracks: this.localStream.getTracks().map(track => ({
+                kind: track.kind,
+                id: track.id,
+                label: track.label,
+                enabled: track.enabled,
+                readyState: track.readyState,
+                muted: track.muted
+            }))
+        };
+    }
+
+    /**
+     * 비디오 해상도 변경
+     * @param {Object} constraints - { width, height, frameRate }
+     */
+    async applyVideoConstraints(constraints) {
+        if (!this.localStream) {
+            throw new Error('No local stream available');
+        }
+
+        const videoTrack = this.localStream.getVideoTracks()[0];
+        if (!videoTrack) {
+            throw new Error('No video track available');
+        }
+
+        try {
+            await videoTrack.applyConstraints(constraints);
+            this.emit('videoConstraintsApplied', { constraints });
+            this.logger.info('Video constraints applied:', constraints);
+        } catch (error) {
+            this.logger.error('Failed to apply video constraints:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * 현재 비디오 설정 가져오기
+     * @returns {MediaTrackSettings|null}
+     */
+    getVideoSettings() {
+        if (!this.localStream) return null;
+
+        const videoTrack = this.localStream.getVideoTracks()[0];
+        return videoTrack ? videoTrack.getSettings() : null;
+    }
+
+    /**
+     * 현재 오디오 설정 가져오기
+     * @returns {MediaTrackSettings|null}
+     */
+    getAudioSettings() {
+        if (!this.localStream) return null;
+
+        const audioTrack = this.localStream.getAudioTracks()[0];
+        return audioTrack ? audioTrack.getSettings() : null;
+    }
+
+    /**
+     * 로그 레벨 설정
+     * @param {number} level
+     */
+    setLogLevel(level) {
+        this.logger.setLevel(level);
+    }
+
+    /**
+     * 리소스 정리
+     */
+    destroy() {
+        this.stopAll();
+        this.stopDeviceChangeDetection();
+        this.removeAllListeners();
+        this.logger.info('MediaStreamManager destroyed');
+    }
+}
+
+export default MediaStreamManager;