@thinkingcat/auth-utils 1.0.49 → 2.0.0

package/dist/index.js

@@ -1,1642 +1,34 @@
-import { jwtVerify, EncryptJWT } from 'jose';
-// ============================================================================
-// UTILITY FUNCTIONS
-// ============================================================================
-/**
- * 조건부 로깅 유틸리티 (환경 변수 AUTH_UTILS_DEBUG=true 시에만 로그 출력)
- */
-function debugLog(context, ...args) {
-    if (process.env.AUTH_UTILS_DEBUG === 'true' || process.env.NODE_ENV === 'development') {
-        console.log(`[${context}]`, ...args);
-    }
-}
-function debugError(context, ...args) {
-    if (process.env.AUTH_UTILS_DEBUG === 'true' || process.env.NODE_ENV === 'development') {
-        console.error(`[${context}]`, ...args);
-    }
-}
-/**
- * Edge Runtime 호환을 위해 Web Crypto API 사용
- */
-async function createHashSHA256(data) {
-    const encoder = new TextEncoder();
-    const dataBuffer = encoder.encode(data);
-    const hashBuffer = await crypto.subtle.digest('SHA-256', dataBuffer);
-    const hashArray = Array.from(new Uint8Array(hashBuffer));
-    return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
-}
-/**
- * Edge Runtime 호환을 위해 next/server를 동적 import
- */
-async function getNextServer() {
-    return await import('next/server');
-}
-/**
- * NextAuth 세션 토큰 쿠키를 삭제하는 헬퍼 함수
- */
-function deleteNextAuthSessionCookie(response, isProduction) {
-    const cookieName = isProduction
-        ? '__Secure-next-auth.session-token'
-        : 'next-auth.session-token';
-    response.cookies.delete(cookieName);
-}
-/**
- * 모든 인증 관련 쿠키를 삭제하는 헬퍼 함수
- */
-function clearAllAuthCookies(response, cookiePrefix, isProduction) {
-    clearAuthCookies(response, cookiePrefix);
-    deleteNextAuthSessionCookie(response, isProduction);
-}
-// ============================================================================
-// JWT CORE FUNCTIONS
-// ============================================================================
-/**
- * 토큰 검증 및 디코딩
- * @param accessToken JWT access token
- * @param secret JWT 서명에 사용할 secret key
- * @returns 검증된 payload 또는 null
- */
-export async function verifyToken(accessToken, secret) {
-    try {
-        const secretBytes = new TextEncoder().encode(secret);
-        const { payload } = await jwtVerify(accessToken, secretBytes);
-        if (payload && typeof payload === 'object' && payload.email) {
-            return { payload: payload };
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * payload에서 역할 추출 (서비스별)
- * @param payload JWT payload
- * @param serviceId 서비스 ID (필수)
- * @param defaultRole 기본 역할 (기본값: 'ADMIN')
- * @returns 추출된 역할
- */
-export function extractRoleFromPayload(payload, serviceId, defaultRole = 'ADMIN') {
-    const services = payload.services || [];
-    const service = services.find((s) => s.serviceId === serviceId);
-    return service?.role || payload.role || defaultRole;
-}
-/**
- * payload에서 NextAuth JWT 객체 생성
- * @param payload JWT payload
- * @param serviceId 서비스 ID (필수)
- * @returns NextAuth JWT 객체
- */
-export function createNextAuthJWT(payload, serviceId) {
-    const services = payload.services || [];
-    const service = services.find((s) => s.serviceId === serviceId);
-    const effectiveRole = service?.role || payload.role || 'ADMIN';
-    // name 필드 결정: payload.name이 있으면 사용, 없으면 decryptedEmail 또는 maskedEmail 사용
-    // email은 암호화되어 있을 수 있으므로 직접 사용하지 않음
-    const displayName = payload.name
-        || payload.decryptedEmail
-        || payload.maskedEmail
-        || 'User';
-    const jwt = {
-        id: (payload.id || payload.sub),
-        email: payload.email,
-        name: displayName,
-        role: effectiveRole, // Role enum 타입 (string으로 캐스팅)
-        services: payload.services,
-        phoneVerified: payload.phoneVerified ?? false,
-        emailVerified: payload.emailVerified ?? false,
-        smsVerified: payload.smsVerified ?? false,
-        iat: Math.floor(Date.now() / 1000),
-        exp: Math.floor(Date.now() / 1000) + (30 * 24 * 60 * 60), // 30일
-    };
-    // 선택적 필드들
-    if (payload.phone)
-        jwt.phone = payload.phone;
-    if (payload.isPasswordReset)
-        jwt.isPasswordReset = payload.isPasswordReset;
-    if (payload.decryptedEmail)
-        jwt.decryptedEmail = payload.decryptedEmail;
-    if (payload.decryptedPhone)
-        jwt.decryptedPhone = payload.decryptedPhone;
-    if (payload.emailHash)
-        jwt.emailHash = payload.emailHash;
-    if (payload.maskedEmail)
-        jwt.maskedEmail = payload.maskedEmail;
-    if (payload.phoneHash)
-        jwt.phoneHash = payload.phoneHash;
-    if (payload.maskedPhone)
-        jwt.maskedPhone = payload.maskedPhone;
-    if (payload.refreshToken)
-        jwt.refreshToken = payload.refreshToken;
-    if (payload.accessToken)
-        jwt.accessToken = payload.accessToken;
-    if (payload.accessTokenExpires)
-        jwt.accessTokenExpires = payload.accessTokenExpires;
-    if (payload.serviceId)
-        jwt.serviceId = payload.serviceId;
-    return jwt;
-}
-/**
- * NextAuth JWT를 인코딩된 세션 토큰으로 변환
- * @param jwt NextAuth JWT 객체
- * @param secret JWT 서명에 사용할 secret key
- * @param maxAge 토큰 유효 기간 (초, 기본값: 30일)
- * @returns 인코딩된 세션 토큰
- */
-export async function encodeNextAuthToken(jwt, secret, maxAge = 30 * 24 * 60 * 60) {
-    // NextAuth의 encode() 함수를 우선적으로 사용 (가장 호환성 좋음)
-    try {
-        const { encode } = await import('next-auth/jwt');
-        debugLog('encodeNextAuthToken', 'Using next-auth/jwt encode');
-        const encoded = await encode({
-            token: jwt,
-            secret: secret,
-            maxAge: maxAge,
-        });
-        debugLog('encodeNextAuthToken', 'NextAuth encode successful, length:', encoded.length);
-        return encoded;
-    }
-    catch (error) {
-        // Edge Runtime에서 encode가 작동하지 않을 수 있으므로
-        // jose의 EncryptJWT를 fallback으로 사용
-        debugLog('encodeNextAuthToken', 'NextAuth encode failed, using jose EncryptJWT fallback', error);
-        // NextAuth는 secret을 SHA-256 해시하여 32바이트 키로 사용
-        const secretHash = await createHashSHA256(secret);
-        // SHA-256 해시는 64자 hex 문자열이므로, 32바이트로 변환
-        const keyBytes = new Uint8Array(32);
-        for (let i = 0; i < 32; i++) {
-            keyBytes[i] = parseInt(secretHash.slice(i * 2, i * 2 + 2), 16);
-        }
-        const now = Math.floor(Date.now() / 1000);
-        // EncryptJWT를 사용하여 JWE 토큰 생성
-        // NextAuth는 'dir' 키 관리와 'A256GCM' 암호화를 사용
-        try {
-            const token = await new EncryptJWT(jwt)
-                .setProtectedHeader({
-                alg: 'dir', // Direct key agreement
-                enc: 'A256GCM' // AES-256-GCM encryption
-            })
-                .setIssuedAt(now)
-                .setExpirationTime(now + maxAge)
-                .setJti(crypto.randomUUID())
-                .encrypt(keyBytes);
-            debugLog('encodeNextAuthToken', 'EncryptJWT fallback successful, length:', token.length);
-            return token;
-        }
-        catch (encryptError) {
-            debugError('encodeNextAuthToken', 'EncryptJWT also failed:', encryptError);
-            throw new Error(`Failed to encode NextAuth token: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-}
-export function setCustomTokens(response, accessToken, optionsOrRefreshToken, options) {
-    // 옵션 파라미터 처리: refreshToken과 options를 분리
-    let refreshTokenValue;
-    let cookiePrefix;
-    let isProduction;
-    let cookieDomain;
-    if (typeof optionsOrRefreshToken === 'string') {
-        // 기존 방식: refreshToken이 문자열로 전달된 경우
-        refreshTokenValue = optionsOrRefreshToken;
-        const { cookiePrefix: prefix, isProduction: prod = false, cookieDomain: domain, } = options || {};
-        if (!prefix) {
-            throw new Error('cookiePrefix is required');
-        }
-        cookiePrefix = prefix;
-        isProduction = prod;
-        cookieDomain = domain;
-    }
-    else {
-        // 새로운 방식: options 객체로 전달된 경우
-        const opts = optionsOrRefreshToken || {};
-        refreshTokenValue = opts.refreshToken;
-        if (!opts.cookiePrefix) {
-            throw new Error('cookiePrefix is required');
-        }
-        cookiePrefix = opts.cookiePrefix;
-        isProduction = opts.isProduction || false;
-        cookieDomain = opts.cookieDomain;
-    }
-    // 쿠키 옵션 생성
-    const cookieOptions = {
-        httpOnly: true,
-        secure: isProduction,
-        sameSite: isProduction ? 'none' : 'lax',
-        path: '/',
-        maxAge: 15 * 60, // access token: 15분
-    };
-    if (cookieDomain) {
-        cookieOptions.domain = cookieDomain;
-    }
-    // access_token 설정
-    const accessTokenName = `${cookiePrefix}_access_token`;
-    response.cookies.delete(accessTokenName);
-    response.cookies.set(accessTokenName, accessToken, cookieOptions);
-    debugLog('setCustomTokens', `Set ${accessTokenName} cookie:`, {
-        hasValue: !!accessToken,
-        maxAge: cookieOptions.maxAge,
-        domain: cookieOptions.domain,
-        secure: cookieOptions.secure,
-        sameSite: cookieOptions.sameSite,
-    });
-    // refresh_token 설정 (있는 경우)
-    if (refreshTokenValue) {
-        const refreshTokenName = `${cookiePrefix}_refresh_token`;
-        const refreshCookieOptions = {
-            ...cookieOptions,
-            maxAge: 30 * 24 * 60 * 60, // refresh token: 30일
-        };
-        response.cookies.set(refreshTokenName, refreshTokenValue, refreshCookieOptions);
-        debugLog('setCustomTokens', `Set ${refreshTokenName} cookie:`, {
-            hasValue: !!refreshTokenValue,
-            maxAge: refreshCookieOptions.maxAge,
-            domain: refreshCookieOptions.domain,
-        });
-    }
-}
-/**
- * NextAuth 세션 토큰만 설정
- * @param response NextResponse 객체
- * @param sessionToken NextAuth session token
- * @param options 쿠키 설정 옵션
- * @param options.isProduction 프로덕션 환경 여부 (기본값: false)
- * @param options.cookieDomain 쿠키 도메인 (선택)
- */
-export function setNextAuthToken(response, sessionToken, options = {}) {
-    const { isProduction = false, cookieDomain, } = options;
-    // createNextAuthCookies와 동일한 로직 사용
-    const cookies = createNextAuthCookies({ isProduction, cookieDomain });
-    const cookieName = cookies.sessionToken.name;
-    response.cookies.delete(cookieName);
-    response.cookies.set(cookieName, sessionToken, {
-        ...cookies.sessionToken.options,
-        httpOnly: true,
-        maxAge: 30 * 24 * 60 * 60, // 30일
-    });
-}
-/**
- * 리다이렉트용 HTML 생성
- * @param redirectPath 리다이렉트할 경로
- * @param text 표시할 텍스트 (필수)
- * @returns HTML 문자열
- */
-export function createRedirectHTML(redirectPath, text) {
-    return `
-    <!DOCTYPE html>
-    <html>
-      <head>
-        <meta charset="utf-8">
-        <title>Redirecting...</title>
-        <style>
-          * { margin: 0; padding: 0; box-sizing: border-box; }
-          html, body {
-            width: 100%;
-            height: 100%;
-            overflow: hidden;
-          }
-          body {
-            display: flex;
-            align-items: flex-start;
-            justify-content: flex-start;
-            padding-left: 10%;
-            padding-top: 20%;
-            background: #fff;
-          }
-          .typing-text {
-            font-family: 'Courier New', monospace;
-            font-size: 2.5rem;
-            font-weight: bold;
-            color: #667eea;
-            letter-spacing: 0.1em;
-          }
-          .cursor {
-            display: inline-block;
-            width: 3px;
-            height: 2.5rem;
-            background-color: #667eea;
-            margin-left: 2px;
-            animation: blink 0.7s infinite;
-          }
-          @keyframes blink {
-            0%, 50% { opacity: 1; }
-            51%, 100% { opacity: 0; }
-          }
-        </style>
-      </head>
-      <body>
-        <div class="typing-text">
-          <span id="text"></span><span class="cursor"></span>
-        </div>
-        <script>
-          const text = '${text}';
-          let index = 0;
-          const speed = 100;
-          
-          function type() {
-            if (index < text.length) {
-              document.getElementById('text').textContent += text.charAt(index);
-              index++;
-              setTimeout(type, speed);
-            } else {
-              setTimeout(() => window.location.href = '${redirectPath}', 200);
-            }
-          }
-          
-          type();
-        </script>
-      </body>
-    </html>
-  `;
-}
-/**
- * access token과 refresh token을 사용하여 완전한 인증 세션 생성
- * @param accessToken access token
- * @param secret JWT 서명에 사용할 secret key
- * @param options 추가 옵션
- * @param options.req NextRequest 객체 (필수 - URL origin을 위해 필요)
- * @param options.refreshToken refresh token (선택)
- * @param options.redirectPath 리다이렉트할 경로 (HTTP 302 리다이렉트 사용)
- * @param options.text 응답 메시지 텍스트 (선택사항)
- * @param options.cookiePrefix 쿠키 이름 접두사 (필수)
- * @param options.isProduction 프로덕션 환경 여부 (기본값: false)
- * @param options.cookieDomain 쿠키 도메인 (선택)
- * @param options.serviceId 서비스 ID (필수)
- * @param options.licenseKey 라이센스 키 (필수)
- * @returns NextResponse 객체 (리다이렉트 또는 JSON 응답)
- */
-export async function createAuthResponse(accessToken, secret, options) {
-    await checkLicenseKey(options.licenseKey);
-    const { req, refreshToken, redirectPath, text, cookiePrefix, isProduction = false, cookieDomain, serviceId, } = options;
-    // 1. 토큰 검증
-    const tokenResult = await verifyToken(accessToken, secret);
-    if (!tokenResult) {
-        throw new Error('Invalid token');
-    }
-    const { payload } = tokenResult;
-    // 2. NextAuth JWT 생성
-    const jwt = createNextAuthJWT(payload, serviceId);
-    // refreshToken 추가
-    if (refreshToken) {
-        jwt.refreshToken = refreshToken;
-    }
-    // accessTokenExpires 추가 (15분)
-    jwt.accessTokenExpires = Date.now() + (15 * 60 * 1000);
-    debugLog('createAuthResponse', 'JWT prepared (NextAuth will create session from custom tokens):', {
-        hasId: !!jwt.id,
-        hasEmail: !!jwt.email,
-        hasRole: !!jwt.role,
-        hasRefreshToken: !!jwt.refreshToken,
-    });
-    // 3. Response 생성 (HTTP 302 리다이렉트 사용)
-    const { NextResponse: NextResponseClass } = await getNextServer();
-    // redirectPath가 있으면 302 리다이렉트, 없으면 200 OK
-    const response = redirectPath
-        ? NextResponseClass.redirect(new URL(redirectPath, req.url), { status: 302 })
-        : NextResponseClass.json({ success: true, message: text || 'Authentication successful' }, { status: 200 });
-    // 4. NextAuth 세션 쿠키 생성
-    // 주의: NextAuth는 세션 쿠키를 자동으로 관리하므로, 직접 설정하는 것이 문제를 일으킬 수 있습니다.
-    // 하지만 미들웨어에서는 NextAuth의 정상 플로우를 사용할 수 없으므로, 
-    // NextAuth의 encode()와 decode()가 호환되도록 주의해야 합니다.
-    const nextAuthCookieName = isProduction
-        ? '__Secure-next-auth.session-token'
-        : 'next-auth.session-token';
-    // NextAuth 세션 쿠키 설정을 건너뛰고 커스텀 토큰만 사용
-    // NextAuth는 JWT 콜백을 통해 자동으로 세션 쿠키를 생성하므로,
-    // 미들웨어에서 직접 설정하면 NextAuth가 디코딩할 수 없는 경우가 있습니다.
-    // 따라서 커스텀 토큰만 설정하고, NextAuth 세션은 JWT 콜백에서 처리하도록 합니다.
-    debugLog('createAuthResponse', 'Skipping NextAuth session cookie - will be handled by NextAuth JWT callback', {
-        name: nextAuthCookieName,
-        hasJWT: !!jwt,
-        jwtId: jwt?.id,
-    });
-    // 5. 커스텀 토큰 쿠키 설정
-    if (refreshToken) {
-        setCustomTokens(response, accessToken, refreshToken, {
-            cookiePrefix,
-            isProduction,
-            cookieDomain,
-        });
-    }
-    else {
-        setCustomTokens(response, accessToken, {
-            cookiePrefix,
-            isProduction,
-            cookieDomain,
-        });
-    }
-    debugLog('createAuthResponse', 'Custom tokens set successfully');
-    console.log('[createAuthResponse] All cookies set:', {
-        nextAuthCookie: nextAuthCookieName,
-        accessTokenCookie: `${cookiePrefix}_access_token`,
-        refreshTokenCookie: refreshToken ? `${cookiePrefix}_refresh_token` : 'none',
-    });
-    return response;
-}
-// ============================================================================
-// SSO INTEGRATION FUNCTIONS
-// ============================================================================
-/**
- * 서비스 구독 유효성 확인 함수
- * @param services 서비스 정보 배열
- * @param serviceId 확인할 서비스 ID
- * @param ssoBaseURL SSO 서버 기본 URL (필수)
- * @returns 구독 유효성 결과
- */
-export function validateServiceSubscription(services, serviceId, ssoBaseURL) {
-    const filteredServices = services.filter(service => service.serviceId === serviceId);
-    if (filteredServices.length === 0) {
-        return {
-            isValid: false,
-            redirectUrl: `${ssoBaseURL}/services/${serviceId}?type=subscription_required`
-        };
-    }
-    const service = filteredServices[0];
-    if (service.status !== "ACTIVE") {
-        return {
-            isValid: false,
-            redirectUrl: `${ssoBaseURL}/services/${service.serviceId}?type=subscription_required`,
-            service
-        };
-    }
-    return {
-        isValid: true,
-        service
-    };
-}
-/**
- * SSO 서버에서 refresh token을 사용하여 새로운 access token을 발급받는 함수
- * @param refreshToken refresh token
- * @param options 옵션
- * @param options.ssoBaseURL SSO 서버 기본 URL (필수)
- * @param options.authServiceKey 인증 서비스 키 (기본값: 환경 변수)
- * @returns SSO refresh token 응답
- */
-export async function refreshSSOToken(refreshToken, options) {
-    const { ssoBaseURL, authServiceKey } = options;
-    if (!authServiceKey) {
-        throw new Error('AUTH_SERVICE_SECRET_KEY not configured');
-    }
-    const refreshResponse = await fetch(`${ssoBaseURL}/api/sso/refresh`, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            'x-auth-service-key': authServiceKey,
-        },
-        body: JSON.stringify({ refreshToken }),
-    });
-    return await refreshResponse.json();
-}
-/**
- * SSO 서버에서 사용자의 refresh token을 가져오는 함수
- * @param userId 사용자 ID
- * @param accessToken access token
- * @param options 옵션
- * @param options.ssoBaseURL SSO 서버 기본 URL (필수)
- * @param options.authServiceKey 인증 서비스 키 (기본값: 환경 변수)
- * @returns refresh token 또는 null
- */
-export async function getRefreshTokenFromSSO(userId, accessToken, options) {
-    const { ssoBaseURL, authServiceKey } = options;
-    if (!authServiceKey) {
-        return null;
-    }
-    try {
-        const refreshResponse = await fetch(`${ssoBaseURL}/api/sso/get-refresh-token`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'x-auth-service-key': authServiceKey,
-            },
-            body: JSON.stringify({
-                userId,
-                accessToken
-            }),
-        });
-        const refreshResult = await refreshResponse.json();
-        if (refreshResponse.ok && refreshResult.success && refreshResult.refreshToken) {
-            return refreshResult.refreshToken;
-        }
-    }
-    catch {
-        // Refresh token 실패해도 access token으로 일단 로그인 가능
-    }
-    return null;
-}
-// ============================================================================
-// TOKEN REFRESH & VERIFICATION FUNCTIONS
-// ============================================================================
-export async function verifyAndRefreshToken(req, secret, options) {
-    const { cookiePrefix, serviceId, isProduction, cookieDomain, text, ssoBaseURL, authServiceKey, forceRefresh = false, } = options;
-    // 1. access_token 쿠키 확인
-    // forceRefresh가 true이면 access token이 있어도 refresh를 시도
-    const accessTokenName = `${cookiePrefix}_access_token`;
-    const accessToken = req.cookies.get(accessTokenName)?.value;
-    if (accessToken && !forceRefresh) {
-        try {
-            const secretBytes = new TextEncoder().encode(secret);
-            const { payload } = await jwtVerify(accessToken, secretBytes);
-            if (payload && typeof payload === 'object' && payload.email) {
-                return { isValid: true, payload: payload };
-            }
-        }
-        catch {
-            // 토큰 검증 실패
-        }
-    }
-    // 리프레시 토큰으로 갱신 시도
-    const refreshTokenName = `${cookiePrefix}_refresh_token`;
-    const refreshToken = req.cookies.get(refreshTokenName)?.value;
-    debugLog('verifyAndRefreshToken', 'Checking refresh:', {
-        hasRefreshToken: !!refreshToken,
-        forceRefresh,
-    });
-    if (refreshToken) {
-        try {
-            if (!ssoBaseURL || !authServiceKey) {
-                debugLog('verifyAndRefreshToken', 'SSO config missing');
-                return { isValid: false, error: 'SSO_CONFIG_MISSING' };
-            }
-            debugLog('verifyAndRefreshToken', 'Attempting token refresh...');
-            const refreshResult = await refreshSSOToken(refreshToken, {
-                ssoBaseURL,
-                authServiceKey,
-            });
-            debugLog('verifyAndRefreshToken', 'Refresh result:', {
-                success: refreshResult.success,
-                hasAccessToken: !!refreshResult.accessToken,
-            });
-            if (refreshResult.success && refreshResult.accessToken) {
-                const newRefreshToken = refreshResult.refreshToken || refreshToken;
-                try {
-                    let payload;
-                    try {
-                        const secretBytes = new TextEncoder().encode(secret);
-                        const { payload: tokenPayload } = await jwtVerify(refreshResult.accessToken, secretBytes);
-                        if (tokenPayload && typeof tokenPayload === 'object' && tokenPayload.email) {
-                            payload = tokenPayload;
-                        }
-                    }
-                    catch {
-                        // 토큰 검증 실패
-                    }
-                    debugLog('verifyAndRefreshToken', 'Updating cookies including NextAuth session...');
-                    // NextResponse.next()를 생성
-                    const { NextResponse: NextResponseClass } = await getNextServer();
-                    const response = NextResponseClass.next();
-                    // NextAuth JWT 생성
-                    const jwt = createNextAuthJWT(payload, serviceId);
-                    if (newRefreshToken) {
-                        jwt.refreshToken = newRefreshToken;
-                    }
-                    jwt.accessTokenExpires = Date.now() + (15 * 60 * 1000);
-                    // NextAuth 세션 쿠키 생성
-                    // 미들웨어에서는 NextAuth JWT callback이 실행되지 않으므로, 
-                    // refresh 후 NextAuth 세션 쿠키를 직접 설정해야 합니다.
-                    try {
-                        const encodedSessionToken = await encodeNextAuthToken(jwt, secret, 30 * 24 * 60 * 60);
-                        setNextAuthToken(response, encodedSessionToken, {
-                            isProduction,
-                            cookieDomain,
-                        });
-                        debugLog('verifyAndRefreshToken', 'NextAuth session cookie set successfully', {
-                            hasJWT: !!jwt,
-                            jwtId: jwt?.id,
-                        });
-                    }
-                    catch (error) {
-                        debugError('verifyAndRefreshToken', 'Failed to set NextAuth session cookie:', error);
-                        // NextAuth 세션 쿠키 설정 실패해도 커스텀 토큰은 설정하므로 계속 진행
-                    }
-                    // 커스텀 토큰 쿠키 설정
-                    if (newRefreshToken) {
-                        setCustomTokens(response, refreshResult.accessToken, newRefreshToken, {
-                            cookiePrefix,
-                            isProduction,
-                            cookieDomain,
-                        });
-                    }
-                    else {
-                        setCustomTokens(response, refreshResult.accessToken, {
-                            cookiePrefix,
-                            isProduction,
-                            cookieDomain,
-                        });
-                    }
-                    debugLog('verifyAndRefreshToken', 'All cookies updated');
-                    return { isValid: true, response, payload };
-                }
-                catch (error) {
-                    debugError('verifyAndRefreshToken', 'Failed to create auth response:', error);
-                    return { isValid: false, error: 'SESSION_CREATION_FAILED' };
-                }
-            }
-            else {
-                debugLog('verifyAndRefreshToken', 'Refresh failed, clearing all cookies');
-                const { NextResponse: NextResponseClass } = await getNextServer();
-                const response = NextResponseClass.next();
-                clearAllAuthCookies(response, options.cookiePrefix, options.isProduction);
-                return { isValid: false, response, error: 'REFRESH_FAILED' };
-            }
-        }
-        catch (error) {
-            debugError('verifyAndRefreshToken', 'Token refresh error:', error);
-            const { NextResponse: NextResponseClass } = await getNextServer();
-            const response = NextResponseClass.next();
-            clearAllAuthCookies(response, options.cookiePrefix, options.isProduction);
-            return { isValid: false, response, error: 'REFRESH_ERROR' };
-        }
-    }
-    return { isValid: false, error: 'NO_TOKEN' };
-}
-// ============================================================================
-// HELPER FUNCTIONS
-// ============================================================================
-/**
- * 에러 페이지로 리다이렉트하는 헬퍼 함수
- * @param req NextRequest 객체
- * @param code 에러 코드
- * @param message 에러 메시지
- * @param errorPath 에러 페이지 경로 (기본값: '/error')
- * @returns NextResponse 리다이렉트 응답
- */
-export async function redirectToError(req, code, message, errorPath = '/error') {
-    const url = new URL(errorPath, req.url);
-    url.searchParams.set('code', code);
-    url.searchParams.set('message', message);
-    const { NextResponse: NextResponseClass } = await getNextServer();
-    return NextResponseClass.redirect(url);
-}
-/**
- * 인증 쿠키를 삭제하는 헬퍼 함수
- * @param response NextResponse 객체
- * @param cookiePrefix 쿠키 이름 접두사 (필수)
- * @returns NextResponse 객체
- */
-export function clearAuthCookies(response, cookiePrefix) {
-    response.cookies.delete(`${cookiePrefix}_access_token`);
-    response.cookies.delete(`${cookiePrefix}_refresh_token`);
-    return response;
-}
-/**
- * JWT에서 서비스별 역할을 추출하는 헬퍼 함수
- * @param token NextAuth JWT 객체 또는 null
- * @param serviceId 서비스 ID (필수)
- * @returns 추출된 역할 또는 undefined
- */
-export function getEffectiveRole(token, serviceId) {
-    if (!token)
-        return undefined;
-    // token이 이미 JWT 객체인 경우 role을 직접 사용
-    if (token.role) {
-        return token.role;
-    }
-    // services에서 추출
-    const services = token.services || [];
-    const service = services.find((s) => s.serviceId === serviceId);
-    return service?.role;
-}
-/**
- * 구독이 필요한 경로인지 확인하는 헬퍼 함수
- * @param pathname 경로명
- * @param role 사용자 역할
- * @param subscriptionRequiredPaths 구독이 필요한 경로 배열
- * @param systemAdminRole 시스템 관리자 역할 (기본값: 'SYSTEM_ADMIN')
- * @returns 구독이 필요한지 여부
- */
-export function requiresSubscription(pathname, role, subscriptionRequiredPaths, systemAdminRole = 'SYSTEM_ADMIN') {
-    // 시스템 관리자는 구독 확인 제외
-    if (role === systemAdminRole) {
-        return false;
-    }
-    // 구독이 필요한 경로인지 확인
-    return subscriptionRequiredPaths.some(path => pathname.startsWith(path));
-}
-// ============================================================================
-// NEXTAUTH CONFIGURATION FUNCTIONS
-// ============================================================================
-// 유효한 라이센스 키 해시 목록
-const VALID_LICENSE_KEY_HASHES = new Set([
-    '73bce4f3b64804c255cdab450d759a8b53038f9edb59ae42d9988b08dfd007e2',
-]);
-/**
- * NextAuth 쿠키 설정 생성
- * @param options 옵션
- * @param options.isProduction 프로덕션 환경 여부
- * @param options.cookieDomain 쿠키 도메인 (선택)
- * @returns NextAuth 쿠키 설정 객체
- */
-export function createNextAuthCookies(options) {
-    const { isProduction = false, cookieDomain } = options;
-    const isSecure = isProduction;
-    // cookieDomain이 설정되어 있으면 같은 도메인/서브도메인 간 쿠키 공유를 위해 'lax' 사용
-    // cookieDomain이 없고 프로덕션 환경이면 크로스 도메인을 위해 'none' 사용
-    // 개발 환경이면 항상 'lax' 사용
-    const sameSiteValue = cookieDomain ? 'lax' : (isSecure ? 'none' : 'lax');
-    return {
-        sessionToken: {
-            name: isSecure ? `__Secure-next-auth.session-token` : `next-auth.session-token`,
-            options: {
-                httpOnly: true,
-                sameSite: sameSiteValue,
-                path: '/',
-                secure: isSecure,
-                ...(cookieDomain && { domain: cookieDomain }),
-            },
-        },
-        callbackUrl: {
-            name: isSecure ? `__Secure-next-auth.callback-url` : `next-auth.callback-url`,
-            options: {
-                sameSite: sameSiteValue,
-                path: '/',
-                secure: isSecure,
-                ...(cookieDomain && { domain: cookieDomain }),
-            },
-        },
-        csrfToken: {
-            name: isSecure ? `__Secure-next-auth.csrf-token` : `next-auth.csrf-token`,
-            options: {
-                httpOnly: true,
-                sameSite: sameSiteValue,
-                path: '/',
-                secure: isSecure,
-                ...(cookieDomain && { domain: cookieDomain }),
-            },
-        },
-    };
-}
-/**
- * NextAuth 기본 설정 생성
- * @param options 옵션
- * @param options.secret NextAuth secret
- * @param options.isProduction 프로덕션 환경 여부
- * @param options.cookieDomain 쿠키 도메인 (선택)
- * @param options.signInPath 로그인 페이지 경로 (기본값: '/login')
- * @param options.errorPath 에러 페이지 경로 (기본값: '/login')
- * @param options.nextAuthUrl NextAuth URL (선택)
- * @param options.sessionMaxAge 세션 최대 유지 시간 (초, 기본값: 30일)
- * @param options.jwtMaxAge JWT 최대 유지 시간 (초, 기본값: 30일)
- * @returns NextAuth 기본 설정 객체
- */
-export function createNextAuthBaseConfig(options) {
-    const { secret, isProduction = false, cookieDomain, signInPath = '/login', errorPath = '/login', nextAuthUrl, sessionMaxAge = 30 * 24 * 60 * 60, // 30일
-    jwtMaxAge = 30 * 24 * 60 * 60, // 30일
-     } = options;
-    return {
-        session: {
-            strategy: 'jwt',
-            maxAge: sessionMaxAge,
-        },
-        jwt: {
-            maxAge: jwtMaxAge,
-        },
-        providers: [],
-        ...(nextAuthUrl && { url: nextAuthUrl }),
-        pages: {
-            signIn: signInPath,
-            error: errorPath,
-        },
-        cookies: createNextAuthCookies({ isProduction, cookieDomain }),
-        secret,
-    };
-}
-/**
- * JWT 콜백에서 초기 로그인 시 토큰 생성 헬퍼
- * @param token 기존 토큰
- * @param user 사용자 정보
- * @param account 계정 정보
- * @returns 업데이트된 JWT 토큰
- */
-export function createInitialJWTToken(token, user, account) {
-    return {
-        ...token,
-        id: user.id,
-        email: user.email ?? undefined,
-        emailHash: user.emailHash ?? undefined,
-        maskedEmail: user.maskedEmail ?? undefined,
-        phoneHash: user.phoneHash ?? undefined,
-        maskedPhone: user.maskedPhone ?? undefined,
-        role: user.role,
-        phone: user.phone ?? undefined,
-        decryptedEmail: user.decryptedEmail ?? undefined,
-        decryptedPhone: user.decryptedPhone ?? undefined,
-        refreshToken: user.refreshToken ?? undefined,
-        accessTokenExpires: Date.now() + (15 * 60 * 1000), // 15분
-        serviceId: account?.serviceId ?? undefined,
-    };
-}
-/**
- * Session 콜백에서 빈 세션 반환 헬퍼
- * @param session 기존 세션
- * @returns 빈 세션 객체
- */
-export function createEmptySession(session) {
-    return {
-        ...session,
-        user: {
-            ...session.user,
-            id: '',
-            email: null,
-            role: 'GUEST',
-        },
-        expires: new Date().toISOString(),
-    };
-}
-/**
- * Session 콜백에서 토큰 정보를 세션에 매핑하는 헬퍼
- * @param session 기존 세션
- * @param token JWT 토큰
- * @returns 업데이트된 세션
- */
-export function mapTokenToSession(session, token) {
-    if (!session.user) {
-        return session;
-    }
-    const user = session.user;
-    user.id = token.id;
-    user.email = token.email;
-    user.name = token.name;
-    user.role = token.role;
-    user.smsVerified = token.smsVerified;
-    user.emailVerified = token.emailVerified;
-    user.phone = token.phone;
-    user.phoneVerified = token.phoneVerified;
-    user.isPasswordReset = token.isPasswordReset || false;
-    user.decryptedEmail = token.decryptedEmail;
-    user.decryptedPhone = token.decryptedPhone;
-    return session;
-}
-/**
- * JWT 콜백을 위한 통합 헬퍼 함수
- * 초기 로그인, 토큰 갱신, 커스텀 토큰 읽기를 모두 처리
- * @param token 기존 JWT 토큰
- * @param user 사용자 정보 (초기 로그인 시)
- * @param account 계정 정보 (초기 로그인 시)
- * @param options 옵션
- * @param options.secret NextAuth secret (커스텀 토큰 읽기용)
- * @param options.licenseKey 라이센스 키 (커스텀 토큰 읽기용)
- * @param options.serviceId 서비스 ID (커스텀 토큰 읽기용)
- * @param options.cookieName 커스텀 토큰 쿠키 이름 (기본값: '{serviceId}_access_token')
- * @param options.debug 디버깅 로그 출력 여부 (기본값: false)
- * @returns 업데이트된 JWT 토큰
- */
-export async function handleJWTCallback(token, user, account, options) {
-    const { secret, licenseKey, serviceId, cookieName, debug = false, ssoBaseURL, authServiceKey, } = options || {};
-    // 디버깅 로그
-    if (debug) {
-        debugLog('handleJWTCallback', 'Token received:', {
-            hasId: !!token.id,
-            hasEmail: !!token.email,
-            hasRole: !!token.role,
-            hasExpires: !!token.accessTokenExpires,
-        });
-    }
-    // 1. 초기 로그인 시 (providers를 통한 로그인)
-    if (account && user) {
-        debugLog('handleJWTCallback', 'Initial login, creating token from user data');
-        return createInitialJWTToken(token, user, account);
-    }
-    // 2. 커스텀 토큰 쿠키 우선 체크 (middleware에서 refresh한 토큰이 있을 수 있음)
-    if (secret && licenseKey && serviceId) {
-        const cookieNameToUse = cookieName || `${serviceId}_access_token`;
-        debugLog('handleJWTCallback', 'Checking custom token cookie first:', cookieNameToUse);
-        const customJwt = await getJWTFromCustomTokenCookie(cookieNameToUse, secret, serviceId, licenseKey);
-        if (customJwt) {
-            debugLog('handleJWTCallback', 'Found valid custom token cookie, using it');
-            // refreshToken이 있으면 유지
-            if (token.refreshToken) {
-                customJwt.refreshToken = token.refreshToken;
-            }
-            return customJwt;
-        }
-        debugLog('handleJWTCallback', 'No valid custom token cookie found');
-    }
-    // 3. 토큰 유효성 체크
-    const now = Date.now();
-    const expires = token.accessTokenExpires;
-    const hasValidToken = token.id && expires && expires > now;
-    const refreshToken = token.refreshToken;
-    debugLog('handleJWTCallback', 'Token status:', {
-        hasId: !!token.id,
-        hasExpires: !!expires,
-        expiresIn: expires ? Math.round((expires - now) / 1000) + 's' : 'N/A',
-        hasValidToken,
-        hasRefreshToken: !!refreshToken,
-    });
-    // 3-1. nextauth token이 있고 만료되지 않았으면 그대로 사용
-    if (hasValidToken) {
-        debugLog('handleJWTCallback', 'Token is still valid, using existing token');
-        return token;
-    }
-    // 3-2. nextauth token이 없거나 만료됨 → refresh token으로 갱신 시도
-    // (refreshToken이 있고 SSO 설정이 있을 때만)
-    if (refreshToken && ssoBaseURL && authServiceKey && secret) {
-        debugLog('handleJWTCallback', 'Token invalid or expired, attempting SSO refresh');
-        try {
-            debugLog('handleJWTCallback', 'Calling SSO refresh endpoint:', `${ssoBaseURL}/api/sso/refresh`);
-            const response = await fetch(`${ssoBaseURL}/api/sso/refresh`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'x-auth-service-key': authServiceKey,
-                },
-                body: JSON.stringify({ refreshToken }),
-            });
-            debugLog('handleJWTCallback', 'SSO refresh response status:', response.status);
-            if (response.ok) {
-                const result = await response.json();
-                if (result.success && result.accessToken) {
-                    debugLog('handleJWTCallback', 'Successfully refreshed token from SSO');
-                    // 새 액세스 토큰 검증 및 페이로드 추출
-                    const tokenResult = await verifyToken(result.accessToken, secret);
-                    if (tokenResult) {
-                        const newJWT = createNextAuthJWT(tokenResult.payload, serviceId || '');
-                        return {
-                            ...newJWT,
-                            refreshToken, // 기존 refresh token 유지
-                            accessTokenExpires: Date.now() + (15 * 60 * 1000), // 15분
-                        };
-                    }
-                }
-            }
-            debugLog('handleJWTCallback', 'Failed to refresh token from SSO');
-        }
-        catch (error) {
-            console.error('[handleJWTCallback] Error refreshing token:', error);
-        }
-    }
-    else {
-        debugLog('handleJWTCallback', 'Cannot refresh - missing requirements:', {
-            hasRefreshToken: !!refreshToken,
-            hasSSO: !!ssoBaseURL,
-            hasAuthKey: !!authServiceKey,
-            hasSecret: !!secret,
-        });
-    }
-    // 4. refresh 실패 시 - 기존 토큰이 있으면 반환
-    if (token.id) {
-        debugLog('handleJWTCallback', 'Refresh failed, returning existing token (possibly expired)');
-        return token;
-    }
-    // 5. 모든 시도 실패 - 빈 토큰 반환
-    debugLog('handleJWTCallback', 'All attempts failed, returning empty token');
-    return token;
-}
-/**
- * 쿠키에서 커스텀 토큰을 읽어서 NextAuth JWT로 변환하는 헬퍼 함수
- * NextAuth JWT 콜백에서 사용
- * @param cookieName 쿠키 이름 (예: 'checkon_access_token')
- * @param secret JWT 서명에 사용할 secret key
- * @param serviceId 서비스 ID (필수)
- * @param licenseKey 라이센스 키 (필수)
- * @returns NextAuth JWT 객체 또는 null
- */
-export async function getJWTFromCustomTokenCookie(cookieName, secret, serviceId, licenseKey) {
-    debugLog('getJWTFromCustomTokenCookie', `Reading cookie: ${cookieName}`);
-    try {
-        const { cookies } = await import('next/headers');
-        const cookieStore = await cookies();
-        const accessToken = cookieStore.get(cookieName)?.value;
-        if (!accessToken) {
-            debugLog('getJWTFromCustomTokenCookie', 'No access token found in cookies');
-            return null;
-        }
-        await checkLicenseKey(licenseKey);
-        const tokenResult = await verifyToken(accessToken, secret);
-        if (!tokenResult) {
-            debugLog('getJWTFromCustomTokenCookie', 'Token verification failed');
-            return null;
-        }
-        const { payload } = tokenResult;
-        const jwt = createNextAuthJWT(payload, serviceId);
-        // accessTokenExpires 추가 (15분)
-        jwt.accessTokenExpires = Date.now() + (15 * 60 * 1000);
-        // refreshToken 읽기 (쿠키에서)
-        const refreshTokenCookieName = cookieName.replace('_access_token', '_refresh_token');
-        const refreshToken = cookieStore.get(refreshTokenCookieName)?.value;
-        if (refreshToken) {
-            jwt.refreshToken = refreshToken;
-        }
-        debugLog('getJWTFromCustomTokenCookie', 'JWT created successfully from custom token', {
-            hasAccessTokenExpires: !!jwt.accessTokenExpires,
-            hasRefreshToken: !!jwt.refreshToken,
-        });
-        return jwt;
-    }
-    catch (error) {
-        debugError('getJWTFromCustomTokenCookie', `Failed to read ${cookieName}:`, error);
-        return null;
-    }
-}
-// ============================================================================
-// LICENSE & AUTHORIZATION FUNCTIONS
-// ============================================================================
-export async function checkLicenseKey(licenseKey) {
-    if (!licenseKey || licenseKey.length < 10) {
-        throw new Error('License key is required');
-    }
-    const keyHash = await createHashSHA256(licenseKey);
-    if (!VALID_LICENSE_KEY_HASHES.has(keyHash)) {
-        throw new Error('Invalid license key');
-    }
-}
-export function checkRoleAccess(pathname, role, roleConfig) {
-    // 각 역할 설정을 확인
-    for (const [configRole, config] of Object.entries(roleConfig)) {
-        const isPathMatch = config.paths.some(path => pathname.startsWith(path));
-        if (isPathMatch) {
-            // 역할이 정확히 일치하거나 allowedRoles에 포함되어 있으면 허용
-            if (role === configRole || config.allowedRoles?.includes(role)) {
-                return { allowed: true };
-            }
-            // 접근 거부
-            return { allowed: false, message: config.message };
-        }
-    }
-    // 매칭되는 경로가 없으면 허용
-    return { allowed: true };
-}
-// ============================================================================
-// REDIRECT FUNCTIONS
-// ============================================================================
-/**
- * SSO 로그인 페이지로 리다이렉트하는 헬퍼 함수
- * @param req NextRequest 객체
- * @param serviceId 서비스 ID
- * @param ssoBaseURL SSO 서버 기본 URL (필수)
- * @returns NextResponse 리다이렉트 응답
- */
-export async function redirectToSSOLogin(req, serviceId, ssoBaseURL) {
-    const { NextResponse: NextResponseClass } = await getNextServer();
-    return NextResponseClass.redirect(new URL(`${ssoBaseURL}/auth/login?serviceId=${serviceId}`, req.url));
-}
-/**
- * 역할별 대시보드 경로로 리다이렉트하는 헬퍼 함수
- * @param req NextRequest 객체
- * @param role 사용자 역할
- * @param rolePaths 역할별 경로 설정 객체
- * @param defaultPath 기본 경로 (기본값: '/admin')
- * @returns NextResponse 리다이렉트 응답
- */
-export async function redirectToRoleDashboard(req, role, rolePaths, defaultPath = '/admin') {
-    const redirectPath = rolePaths[role] || defaultPath;
-    const { NextResponse: NextResponseClass } = await getNextServer();
-    return NextResponseClass.redirect(new URL(redirectPath, req.url));
-}
-// ============================================================================
-// TOKEN VALIDATION UTILITIES
-// ============================================================================
-/**
- * 토큰이 만료되었는지 확인하는 함수
- * @param token NextAuth JWT 객체
- * @returns 만료 여부
- */
-export function isTokenExpired(token) {
-    if (!token)
-        return true;
-    if (token.exp && typeof token.exp === 'number' && token.exp < Math.floor(Date.now() / 1000)) {
-        return true;
-    }
-    return false;
-}
-/**
- * 토큰이 유효한지 확인하는 함수 (만료 및 필수 필드 체크)
- * @param token NextAuth JWT 객체
- * @returns 유효성 여부
- */
-export function isValidToken(token) {
-    if (!token)
-        return false;
-    if (isTokenExpired(token))
-        return false;
-    if (!token.email || !token.id)
-        return false;
-    return true;
-}
-/**
- * 특정 역할을 가지고 있는지 확인하는 함수
- * @param token NextAuth JWT 객체
- * @param role 확인할 역할
- * @param serviceId 서비스 ID (필수)
- * @returns 역할 보유 여부
- */
-export function hasRole(token, role, serviceId) {
-    if (!token)
-        return false;
-    const effectiveRole = getEffectiveRole(token, serviceId);
-    return effectiveRole === role;
-}
-/**
- * 여러 역할 중 하나라도 가지고 있는지 확인하는 함수
- * @param token NextAuth JWT 객체
- * @param roles 확인할 역할 배열
- * @param serviceId 서비스 ID (필수)
- * @returns 역할 보유 여부
- */
-export function hasAnyRole(token, roles, serviceId) {
-    if (!token)
-        return false;
-    const effectiveRole = getEffectiveRole(token, serviceId);
-    return roles.includes(effectiveRole || '');
-}
-// ============================================================================
-// PATH UTILITIES
-// ============================================================================
-/**
- * 공개 경로인지 확인하는 함수
- * @param pathname 경로명
- * @param publicPaths 공개 경로 배열
- * @returns 공개 경로 여부
- */
-export function isPublicPath(pathname, publicPaths) {
-    return publicPaths.some(path => pathname === path || pathname.startsWith(path));
-}
-/**
- * API 경로인지 확인하는 함수
- * @param pathname 경로명
- * @returns API 경로 여부
- */
-export function isApiPath(pathname) {
-    return pathname.startsWith('/api/');
-}
-/**
- * 보호된 API 경로인지 확인하는 함수
- * @param pathname 경로명
- * @param exemptPaths 제외할 경로 배열
- * @returns 보호된 API 경로 여부
- */
-export function isProtectedApiPath(pathname, exemptPaths = []) {
-    if (!isApiPath(pathname))
-        return false;
-    return !exemptPaths.some(path => pathname.startsWith(path));
-}
-// ============================================================================
-// AUTHENTICATION CHECK FUNCTIONS
-// ============================================================================
-/**
- * NextAuth 토큰과 자체 토큰을 모두 확인하는 통합 인증 체크 함수
- * @param req NextRequest 객체
- * @param secret JWT 서명에 사용할 secret key
- * @param options 옵션
- * @returns 인증 결과
- */
-export async function checkAuthentication(req, secret, options) {
-    const { cookiePrefix, serviceId, getNextAuthToken, } = options;
-    let nextAuthToken = null;
-    if (getNextAuthToken) {
-        nextAuthToken = await getNextAuthToken(req);
-    }
-    if (nextAuthToken && isValidToken(nextAuthToken)) {
-        return {
-            isAuthenticated: true,
-            token: nextAuthToken,
-        };
-    }
-    const authCheck = await verifyAndRefreshToken(req, secret, options);
-    if (authCheck.response) {
-        return {
-            isAuthenticated: true,
-            response: authCheck.response,
-            payload: authCheck.payload,
-        };
-    }
-    if (authCheck.isValid && authCheck.payload) {
-        return {
-            isAuthenticated: true,
-            payload: authCheck.payload,
-        };
-    }
-    return {
-        isAuthenticated: false,
-        error: authCheck.error || 'NO_TOKEN',
-    };
-}
-/**
- * NextAuth 토큰과 자체 토큰을 모두 확인하는 미들웨어용 함수
- * NextAuth 토큰이 있으면 바로 통과, 없으면 자체 토큰을 확인
- * @param req NextRequest 객체
- * @param nextAuthToken NextAuth JWT 토큰 (null 가능)
- * @param secret JWT 서명에 사용할 secret key
- * @param options 옵션
- * @returns 인증 결과
- */
-export async function verifyAndRefreshTokenWithNextAuth(req, nextAuthToken, secret, options) {
-    const { cookiePrefix, isProduction } = options;
-    // NextAuth 세션 토큰 쿠키 확인
-    const nextAuthSessionTokenCookieName = isProduction
-        ? '__Secure-next-auth.session-token'
-        : 'next-auth.session-token';
-    const nextAuthCookieValue = req.cookies.get(nextAuthSessionTokenCookieName)?.value;
-    const hasNextAuthSessionTokenCookie = !!nextAuthCookieValue;
-    debugLog('verifyAndRefreshTokenWithNextAuth', 'NextAuth cookie check:', {
-        cookieName: nextAuthSessionTokenCookieName,
-        hasCookie: hasNextAuthSessionTokenCookie,
-        cookieLength: nextAuthCookieValue?.length || 0,
-        cookiePrefix: nextAuthCookieValue?.substring(0, 30) + '...' || 'none',
-    });
-    // NextAuth 토큰 확인
-    const hasValidNextAuthToken = nextAuthToken && isValidToken(nextAuthToken);
-    // Access token 확인
-    const accessTokenName = `${cookiePrefix}_access_token`;
-    const accessToken = req.cookies.get(accessTokenName)?.value;
-    let hasValidAccessToken = false;
-    if (accessToken) {
-        try {
-            const secretBytes = new TextEncoder().encode(secret);
-            const { payload } = await jwtVerify(accessToken, secretBytes);
-            if (payload && typeof payload === 'object' && payload.email) {
-                hasValidAccessToken = true;
-            }
-        }
-        catch {
-            // 토큰 검증 실패
-        }
-    }
-    // Refresh token 확인
-    const refreshTokenName = `${cookiePrefix}_refresh_token`;
-    const refreshToken = req.cookies.get(refreshTokenName)?.value;
-    debugLog('verifyAndRefreshTokenWithNextAuth', 'Token status:', {
-        hasNextAuthCookie: hasNextAuthSessionTokenCookie,
-        hasValidNextAuth: hasValidNextAuthToken,
-        hasValidAccess: hasValidAccessToken,
-        hasRefresh: !!refreshToken,
-    });
-    // NextAuth cookie와 access token이 모두 유효하면 통과
-    if (hasValidNextAuthToken && hasValidAccessToken) {
-        debugLog('verifyAndRefreshTokenWithNextAuth', 'Both NextAuth and access tokens are valid');
-        // payload 추출
-        let payload;
-        if (accessToken) {
-            try {
-                const secretBytes = new TextEncoder().encode(secret);
-                const result = await jwtVerify(accessToken, secretBytes);
-                payload = result.payload;
-            }
-            catch {
-                // 이미 검증됐으므로 실패하지 않을 것
-            }
-        }
-        return {
-            isValid: true,
-            token: nextAuthToken,
-            payload
-        };
-    }
-    // NextAuth cookie가 없거나 access token이 없으면 refresh 시도
-    if (refreshToken && (!hasValidNextAuthToken || !hasValidAccessToken)) {
-        debugLog('verifyAndRefreshTokenWithNextAuth', 'Missing NextAuth or access token, attempting refresh');
-        const authCheck = await verifyAndRefreshToken(req, secret, {
-            ...options,
-            forceRefresh: true,
-        });
-        // refresh 후 NextAuth token 재조회 (새로 생성된 cookie에서)
-        let refreshedToken = null;
-        if (authCheck.isValid && authCheck.payload) {
-            // payload에서 JWT 생성
-            refreshedToken = createNextAuthJWT(authCheck.payload, options.serviceId);
-        }
-        return {
-            ...authCheck,
-            token: refreshedToken || undefined
-        };
-    }
-    // 하나라도 유효하면 일단 통과 (refresh token이 없는 경우)
-    if (hasValidNextAuthToken || hasValidAccessToken) {
-        debugLog('verifyAndRefreshTokenWithNextAuth', 'At least one token is valid (no refresh token)');
-        // payload 추출
-        let payload;
-        if (accessToken && hasValidAccessToken) {
-            try {
-                const secretBytes = new TextEncoder().encode(secret);
-                const result = await jwtVerify(accessToken, secretBytes);
-                payload = result.payload;
-            }
-            catch {
-                // 무시
-            }
-        }
-        return {
-            isValid: true,
-            token: nextAuthToken || (payload ? createNextAuthJWT(payload, options.serviceId) : undefined),
-            payload
-        };
-    }
-    debugLog('verifyAndRefreshTokenWithNextAuth', 'No tokens available');
-    return { isValid: false, error: 'NO_TOKEN' };
-}
-// ============================================================================
-// MIDDLEWARE CONFIGURATION & HANDLER
-// ============================================================================
-/**
- * 기본 미들웨어 설정을 생성하는 함수
- * @param config 커스텀 설정 (필수: serviceId 포함)
- * @param defaults 기본 설정값 (선택사항, 제공하지 않으면 최소 기본값 사용)
- * @returns 미들웨어 설정 객체
- */
-export function createMiddlewareConfig(config, defaults) {
-    // 기본값 설정
-    const defaultPublicPaths = defaults?.publicPaths || [
-        '/robots.txt',
-        '/sitemap.xml',
-        '/ads.txt',
-        '/images',
-        '/login',
-        '/register',
-        '/forgot-password',
-        '/reset-password',
-        '/about',
-        '/pricing',
-        '/support',
-        '/terms',
-        '/privacy',
-        '/refund',
-        '/error',
-    ];
-    const defaultSubscriptionRequiredPaths = defaults?.subscriptionRequiredPaths || [
-        '/admin',
-        '/teacher',
-        '/student',
-        '/personal',
-    ];
-    const defaultSubscriptionExemptApiPaths = defaults?.subscriptionExemptApiPaths || [
-        '/api/auth',
-        '/api/sso',
-        '/api/admin/subscription',
-        '/api/admin/payment-methods',
-    ];
-    const defaultAuthApiPaths = defaults?.authApiPaths || [
-        '/api/auth/send-verification',
-        '/api/auth/verify-code',
-        '/api/auth/verify-user',
-        '/api/auth/select-academy',
-    ];
-    const defaultRolePaths = defaults?.rolePaths || {
-        SYSTEM_ADMIN: '/system',
-        ADMIN: '/admin',
-        TEACHER: '/teacher',
-        STUDENT: '/student',
-    };
-    const defaultSystemAdminRole = defaults?.systemAdminRole || 'SYSTEM_ADMIN';
-    const defaultErrorPath = defaults?.errorPath || '/error';
-    // 커스텀 설정으로 병합
-    return {
-        publicPaths: config.publicPaths || defaultPublicPaths,
-        subscriptionRequiredPaths: config.subscriptionRequiredPaths || defaultSubscriptionRequiredPaths,
-        subscriptionExemptApiPaths: config.subscriptionExemptApiPaths || defaultSubscriptionExemptApiPaths,
-        authApiPaths: config.authApiPaths || defaultAuthApiPaths,
-        rolePaths: config.rolePaths || defaultRolePaths,
-        roleAccessConfig: config.roleAccessConfig || {},
-        systemAdminRole: config.systemAdminRole || defaultSystemAdminRole,
-        errorPath: config.errorPath || defaultErrorPath,
-        serviceId: config.serviceId,
-    };
-}
-/**
- * 통합 미들웨어 핸들러 함수
- * 모든 인증, 권한, 구독 체크를 포함한 완전한 미들웨어 로직
- * @param req NextRequest 객체
- * @param config 미들웨어 설정
- * @param options 미들웨어 실행 옵션 (secret 필수)
- * @returns NextResponse 또는 null (다음 미들웨어로 진행)
- */
-export async function handleMiddleware(req, config, options) {
-    // Edge Runtime 호환을 위해 next/server를 한 번만 import
-    const { NextResponse: NextResponseClass } = await getNextServer();
-    try {
-        const pathname = req.nextUrl.pathname;
-        const { secret, isProduction, cookieDomain, getNextAuthToken, licenseKey } = options;
-        debugLog('handleMiddleware', `Processing: ${pathname}`);
-        await checkLicenseKey(licenseKey);
-        if (!config.serviceId) {
-            throw new Error('serviceId is required in middleware config');
-        }
-        const serviceId = config.serviceId;
-        const cookiePrefix = serviceId;
-        let token = null;
-        if (getNextAuthToken) {
-            token = await getNextAuthToken(req);
-            debugLog('handleMiddleware', 'Custom getNextAuthToken result:', { hasToken: !!token });
-        }
-        else {
-            try {
-                const { getToken } = await import('next-auth/jwt');
-                token = await getToken({ req, secret });
-                debugLog('handleMiddleware', 'getToken result:', { hasToken: !!token });
-            }
-            catch (error) {
-                debugLog('handleMiddleware', 'getToken failed:', error);
-                // NextAuth가 없으면 null 유지
-            }
-        }
-        debugLog('handleMiddleware', 'Token status:', {
-            hasToken: !!token,
-            hasId: !!token?.id,
-        });
-        const effectiveRole = getEffectiveRole(token, serviceId);
-        debugLog('handleMiddleware', `Effective role: ${effectiveRole || 'none'}`);
-        // 1. API 요청 처리
-        if (pathname.startsWith('/api/')) {
-            if (config.authApiPaths.includes(pathname)) {
-                return NextResponseClass.next();
-            }
-            if (config.subscriptionExemptApiPaths.some((path) => pathname.startsWith(path))) {
-                return NextResponseClass.next();
-            }
-            const authCheck = await verifyAndRefreshTokenWithNextAuth(req, token, secret, {
-                cookiePrefix,
-                serviceId,
-                isProduction,
-                cookieDomain,
-                text: serviceId,
-                ssoBaseURL: options.ssoBaseURL,
-                authServiceKey: options.authServiceKey,
-                licenseKey: options.licenseKey,
-            });
-            if (authCheck.response) {
-                return authCheck.response;
-            }
-            if (!authCheck.isValid) {
-                const response = await redirectToError(req, 'UNAUTHORIZED', '인증이 필요합니다.', config.errorPath);
-                return clearAuthCookies(response, cookiePrefix);
-            }
-            return NextResponseClass.next();
-        }
-        // 2. 루트 경로 처리 - SSO 토큰 처리 (인증 체크보다 먼저!)
-        if (pathname === '/') {
-            const tokenParam = req.nextUrl.searchParams.get('token');
-            console.log('[handleMiddleware] Root path check:', {
-                pathname,
-                hasTokenParam: !!tokenParam,
-                tokenLength: tokenParam?.length || 0,
-            });
-            if (tokenParam) {
-                debugLog('handleMiddleware', 'Processing SSO token from query parameter');
-                console.log('[handleMiddleware] Processing SSO token from query parameter');
-                try {
-                    // 1. 토큰 검증
-                    const tokenResult = await verifyToken(tokenParam, secret);
-                    if (!tokenResult) {
-                        throw new Error('Invalid token');
-                    }
-                    const { payload } = tokenResult;
-                    // 2. 역할 추출
-                    const defaultRole = Object.keys(config.rolePaths)[0] || 'ADMIN';
-                    const tokenRole = extractRoleFromPayload(payload, serviceId, defaultRole);
-                    debugLog('handleMiddleware', `Extracted role: ${tokenRole}`);
-                    // 3. Refresh token 가져오기 (서버 간 통신)
-                    const userId = payload.id || payload.sub || payload.userId || '';
-                    const ssoBaseURL = options.ssoBaseURL;
-                    const authServiceKey = options.authServiceKey;
-                    debugLog('handleMiddleware', 'Getting refresh token from SSO:', {
-                        userId,
-                        hasSSO: !!ssoBaseURL,
-                        hasAuthKey: !!authServiceKey,
-                    });
-                    let refreshToken = '';
-                    if (authServiceKey && userId) {
-                        try {
-                            const refreshTokenResult = await getRefreshTokenFromSSO(userId, tokenParam, { ssoBaseURL, authServiceKey });
-                            refreshToken = refreshTokenResult || '';
-                            debugLog('handleMiddleware', 'Refresh token result:', {
-                                hasRefreshToken: !!refreshToken,
-                                length: refreshToken.length,
-                            });
-                        }
-                        catch (error) {
-                            debugError('handleMiddleware', 'Failed to get refresh token:', error);
-                            // refresh token이 없어도 access token으로는 로그인 가능
-                        }
-                    }
-                    else {
-                        debugLog('handleMiddleware', 'Skipping refresh token fetch:', {
-                            hasUserId: !!userId,
-                            hasAuthKey: !!authServiceKey,
-                        });
-                    }
-                    // 4. 자체 토큰 생성 및 쿠키 설정
-                    const redirectPath = config.rolePaths[tokenRole] || config.rolePaths[defaultRole] || '/admin';
-                    debugLog('handleMiddleware', `Creating auth response, redirect to: ${redirectPath}`);
-                    console.log('[handleMiddleware] Creating auth response:', {
-                        redirectPath,
-                        hasRefreshToken: !!refreshToken,
-                        cookiePrefix,
-                        isProduction,
-                        cookieDomain,
-                    });
-                    const response = await createAuthResponse(tokenParam, secret, {
-                        req,
-                        refreshToken: refreshToken || undefined,
-                        redirectPath,
-                        text: serviceId,
-                        cookiePrefix,
-                        isProduction,
-                        cookieDomain,
-                        serviceId,
-                        licenseKey: options.licenseKey,
-                    });
-                    console.log('[handleMiddleware] Auth response created, cookies set:', {
-                        hasResponse: !!response,
-                        cookieNames: ['renton_access_token', 'renton_refresh_token', isProduction ? '__Secure-next-auth.session-token' : 'next-auth.session-token'],
-                    });
-                    return response;
-                }
-                catch (error) {
-                    debugError('handleMiddleware', 'Error processing token:', error);
-                    const ssoBaseURL = options.ssoBaseURL;
-                    return await redirectToSSOLogin(req, serviceId, ssoBaseURL);
-                }
-            }
-            // 토큰이 없고 이미 인증된 경우 역할별 대시보드로 리다이렉트
-            if (token && effectiveRole) {
-                return await redirectToRoleDashboard(req, effectiveRole, config.rolePaths);
-            }
-            // 인증되지 않은 경우 SSO 로그인 페이지로 리다이렉트
-            const ssoBaseURL = options.ssoBaseURL;
-            return await redirectToSSOLogin(req, serviceId, ssoBaseURL);
-        }
-        // 3. 공개 경로 처리
-        if (config.publicPaths.some((path) => pathname === path || pathname.startsWith(path))) {
-            if (pathname === '/error' || pathname === '/verification') {
-                return NextResponseClass.next();
-            }
-            if (token && effectiveRole) {
-                return await redirectToRoleDashboard(req, effectiveRole, config.rolePaths);
-            }
-            return NextResponseClass.next();
-        }
-        // 4. 인증 체크
-        const authCheck = await verifyAndRefreshTokenWithNextAuth(req, token, secret, {
-            cookiePrefix,
-            serviceId,
-            isProduction,
-            cookieDomain,
-            text: serviceId,
-            ssoBaseURL: options.ssoBaseURL,
-            authServiceKey: options.authServiceKey,
-            licenseKey: options.licenseKey,
-        });
-        if (authCheck.response) {
-            return authCheck.response;
-        }
-        if (!authCheck.isValid) {
-            const ssoBaseURL = options.ssoBaseURL;
-            return await redirectToSSOLogin(req, serviceId, ssoBaseURL);
-        }
-        // 5. 토큰 확인 - authCheck 결과 재사용 (중복 검증 제거)
-        let finalToken = authCheck.token || token;
-        // authCheck에서 토큰을 반환하지 않았지만 유효한 경우 (드문 케이스)
-        if (!finalToken && authCheck.isValid) {
-            debugLog('handleMiddleware', 'authCheck valid but no token, trying to get NextAuth token');
-            if (getNextAuthToken) {
-                finalToken = await getNextAuthToken(req);
-            }
-            else {
-                try {
-                    const { getToken } = await import('next-auth/jwt');
-                    finalToken = await getToken({ req, secret });
-                }
-                catch {
-                    // NextAuth가 없으면 null 유지
-                }
-            }
-        }
-        if (!finalToken) {
-            const ssoBaseURL = options.ssoBaseURL;
-            return await redirectToSSOLogin(req, serviceId, ssoBaseURL);
-        }
-        // 6. 토큰 에러 체크
-        if (finalToken.error === "RefreshAccessTokenError") {
-            const ssoBaseURL = options.ssoBaseURL;
-            return await redirectToSSOLogin(req, serviceId, ssoBaseURL);
-        }
-        // 7. 토큰 유효성 체크
-        if (!finalToken.role || !finalToken.email) {
-            const ssoBaseURL = options.ssoBaseURL;
-            return await redirectToSSOLogin(req, serviceId, ssoBaseURL);
-        }
-        // 8. 역할 기반 접근 제어
-        const finalEffectiveRole = finalToken.role || getEffectiveRole(finalToken, serviceId) || effectiveRole || '';
-        if (config.roleAccessConfig && Object.keys(config.roleAccessConfig).length > 0 && finalEffectiveRole) {
-            const roleCheck = checkRoleAccess(pathname, finalEffectiveRole, config.roleAccessConfig);
-            if (!roleCheck.allowed) {
-                return await redirectToError(req, 'ACCESS_DENIED', roleCheck.message || '접근 권한이 없습니다.', config.errorPath);
-            }
-        }
-        // 9. 구독 상태 확인 (시스템 관리자 제외)
-        if (finalEffectiveRole && requiresSubscription(pathname, finalEffectiveRole, config.subscriptionRequiredPaths, config.systemAdminRole)) {
-            const services = finalToken.services || [];
-            const ssoBaseURL = options.ssoBaseURL;
-            if (!ssoBaseURL) {
-                throw new Error('ssoBaseURL is required in middleware options');
-            }
-            const subscriptionCheck = validateServiceSubscription(services, serviceId, ssoBaseURL);
-            if (!subscriptionCheck.isValid) {
-                return NextResponseClass.redirect(subscriptionCheck.redirectUrl);
-            }
-        }
-        return null;
-    }
-    catch (error) {
-        debugError('handleMiddleware', 'Middleware error:', error);
-        return await redirectToError(req, 'INTERNAL_ERROR', '서버 오류가 발생했습니다.', config.errorPath);
-    }
-}
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils/logger"), exports);
+__exportStar(require("./utils/crypto"), exports);
+__exportStar(require("./utils/server"), exports);
+__exportStar(require("./utils/redirect"), exports);
+__exportStar(require("./utils/path"), exports);
+__exportStar(require("./utils/license"), exports);
+__exportStar(require("./core/jwt"), exports);
+__exportStar(require("./core/cookies"), exports);
+__exportStar(require("./core/auth-response"), exports);
+__exportStar(require("./core/roles"), exports);
+__exportStar(require("./core/verify"), exports);
+__exportStar(require("./sso/api"), exports);
+__exportStar(require("./nextauth/config"), exports);
+__exportStar(require("./nextauth/callbacks"), exports);
+__exportStar(require("./nextauth/session"), exports);
+__exportStar(require("./middleware/config"), exports);
+__exportStar(require("./middleware/handler"), exports);