Update app.py

app.py

@@ -3,802 +3,364 @@ import requests
 import os
 import json
 from datetime import timedelta
+import logging
+
+# 로깅 설정
+logging.basicConfig(level=logging.DEBUG, 
+                    format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
 
 app = Flask(__name__)
 app.secret_key = os.urandom(24)  # 세션 암호화를 위한 비밀 키
 app.permanent_session_lifetime = timedelta(days=7)  # 세션 유지 기간 설정
 
-# 허깅페이스 URL 목록
-HUGGINGFACE_URLS = [
-    "https://huggingface.co/spaces/ginipick/Tech_Hangman_Game",
-    "https://huggingface.co/spaces/openfree/deepseek_r1_API",
-    "https://huggingface.co/spaces/ginipick/open_Deep-Research",
-    "https://huggingface.co/spaces/aiqmaster/open-deep-research",
-    "https://huggingface.co/spaces/seawolf2357/DeepSeek-R1-32b-search",
-    "https://huggingface.co/spaces/ginigen/LLaDA",
-    "https://huggingface.co/spaces/VIDraft/PHI4-Multimodal",
-    "https://huggingface.co/spaces/ginigen/Ovis2-8B",
-    "https://huggingface.co/spaces/ginigen/Graph-Mind",
-    "https://huggingface.co/spaces/ginigen/Workflow-Canvas",
-    "https://huggingface.co/spaces/ginigen/Design",
-    "https://huggingface.co/spaces/ginigen/Diagram",
-    "https://huggingface.co/spaces/ginigen/Mockup",
-    "https://huggingface.co/spaces/ginigen/Infographic",
-    "https://huggingface.co/spaces/ginigen/Flowchart",
-    "https://huggingface.co/spaces/aiqcamp/FLUX-Vision",
-    "https://huggingface.co/spaces/ginigen/VoiceClone-TTS",
-    "https://huggingface.co/spaces/openfree/Perceptron-Network",
-    "https://huggingface.co/spaces/openfree/Article-Generator",
-]
-
-# URL에서 모델/스페이스 정보 추출
-def extract_model_info(url):
-    parts = url.split('/')
-    if len(parts) < 6:
-        return None
-    
-    if parts[3] == 'spaces' or parts[3] == 'models':
-        return {
-            'type': parts[3],
-            'owner': parts[4],
-            'repo': parts[5],
-            'full_id': f"{parts[4]}/{parts[5]}"
-        }
-    elif len(parts) >= 5:
-        # 다른 형식의 URL
-        return {
-            'type': 'models',  # 기본값
-            'owner': parts[3],
-            'repo': parts[4],
-            'full_id': f"{parts[3]}/{parts[4]}"
-        }
-    
-    return None
-
-# URL의 마지막 부분을 제목으로 추출
-def extract_title(url):
-    parts = url.split("/")
-    title = parts[-1] if parts else ""
-    return title.replace("_", " ").replace("-", " ")
-
-# 허깅페이스 인증 확인 - 수정된 버전
-def validate_token(token):
-    headers = {"Authorization": f"Bearer {token}"}
-    
-    # 수정: 테스트 결과를 바탕으로 whoami-v2 엔드포인트 먼저 시도
-    try:
-        response = requests.get("https://huggingface.co/api/whoami-v2", headers=headers)
-        if response.ok:
-            return True, response.json()
-    except Exception as e:
-        print(f"whoami-v2 토큰 검증 오류: {e}")
-    
-    # 기존 whoami 엔드포인트도 시도
-    try:
-        response = requests.get("https://huggingface.co/api/whoami", headers=headers)
-        if response.ok:
-            return True, response.json()
-    except Exception as e:
-        print(f"whoami 토큰 검증 오류: {e}")
-    
-    return False, None
-
-# 좋아요 목록 가져오기
+# 좋아요 목록 가져오기 함수 - 디버깅 개선
 def get_liked_repos(token):
     headers = {"Authorization": f"Bearer {token}"}
+    liked_models = {}
+    
+    # 1. API에 직접 질의
     endpoints = [
         "/api/me/likes",
         "/api/me/liked-repos",
         "/api/me/favorites"
     ]
     
-    liked_models = {}
+    logger.debug(f"토큰으로 좋아요 목록 가져오기 시도 (토큰 일부: {token[:4]}...)")
     
     for endpoint in endpoints:
+        logger.debug(f"엔드포인트 시도: {endpoint}")
+        
         try:
-            response = requests.get(f"https://huggingface.co{endpoint}", headers=headers)
+            full_url = f"https://huggingface.co{endpoint}"
+            logger.debug(f"API 호출: {full_url}")
+            
+            response = requests.get(full_url, headers=headers)
+            logger.debug(f"응답 상태: {response.status_code}")
+            
             if response.ok:
                 data = response.json()
+                logger.debug(f"응답 데이터 타입: {type(data)}")
+                logger.debug(f"데이터 샘플: {str(data)[:200]}")
+                
                 if isinstance(data, list):
-                    for model in data:
+                    logger.debug(f"목록 길이: {len(data)}")
+                    
+                    for i, model in enumerate(data[:5]):  # 처음 5개만 로깅
+                        logger.debug(f"모델 {i}: {model}")
+                        
                         if isinstance(model, dict):
+                            # 다양한 API 응답 구조 처리
                             if 'owner' in model and 'name' in model:
-                                liked_models[f"{model['owner']}/{model['name']}"] = True
+                                model_id = f"{model['owner']}/{model['name']}"
+                                liked_models[model_id] = True
+                                logger.debug(f"추가된 모델 ID: {model_id}")
                             elif 'id' in model:
                                 liked_models[model['id']] = True
+                                logger.debug(f"추가된 모델 ID: {model['id']}")
+                            elif 'modelId' in model:
+                                liked_models[model['modelId']] = True
+                                logger.debug(f"추가된 모델 ID: {model['modelId']}")
+                            else:
+                                # 다른 필드 확인
+                                logger.debug(f"모델 키: {list(model.keys())}")
+                                
+                                # 직접 owner/repo 형식 추출 시도
+                                if 'repo' in model and 'rowner' in model:
+                                    model_id = f"{model['rowner']}/{model['repo']}"
+                                    liked_models[model_id] = True
+                                    logger.debug(f"추가된 모델 ID: {model_id}")
                 elif isinstance(data, dict):
-                    for key in data:
-                        liked_models[key] = True
+                    logger.debug(f"객체 키: {list(data.keys())}")
+                    
+                    # 객체 구조에 따라 처리
+                    if 'models' in data and isinstance(data['models'], list):
+                        for model in data['models']:
+                            if isinstance(model, dict) and 'id' in model:
+                                liked_models[model['id']] = True
+                                logger.debug(f"추가된 모델 ID: {model['id']}")
+                    else:
+                        # 단순 키-값 구조라면
+                        for key in data:
+                            liked_models[key] = True
+                            logger.debug(f"추가된 키: {key}")
+                
+                logger.debug(f"총 좋아요 항목 수: {len(liked_models)}")
                 
-                print(f"좋아요 목록 가져오기 성공 (엔드포인트: {endpoint})")
-                return liked_models
+                if len(liked_models) > 0:
+                    logger.debug("좋아요 목록 가져오기 성공!")
+                    return liked_models
+            else:
+                logger.debug(f"API 오류: {response.text}")
         except Exception as e:
-            print(f"좋아요 목록 가져오기 오류 (엔드포인트: {endpoint}): {e}")
+            logger.error(f"엔드포인트 {endpoint} 오류: {str(e)}")
     
-    return liked_models
-
-# 좋아요 토글 API 호출
-def toggle_like(token, type_name, owner, repo, is_liked):
-    headers = {"Authorization": f"Bearer {token}"}
-    normalized_type = "spaces" if type_name == "spaces" else "models"
-    method = "DELETE" if is_liked else "POST"
-    url = f"https://huggingface.co/api/{normalized_type}/{owner}/{repo}/like"
+    # 2. 수동 스페이스/모델 확인 (API가 실패한 경우)
+    logger.debug("API 조회 실패, 수동 스페이스/모델 확인 시도")
     
     try:
-        if method == "DELETE":
-            response = requests.delete(url, headers=headers)
-        else:
-            response = requests.post(url, headers=headers)
+        # "me" 페이지 접근해서 HTML에서 좋아요 정보 찾기
+        response = requests.get("https://huggingface.co/me/likes", headers=headers)
         
-        return response.ok, response.status_code
+        if response.ok:
+            logger.debug("좋아요 페이지 가져오기 성공")
+            # 여기서 HTML 파싱할 수도 있지만 복잡하므로 생략
     except Exception as e:
-        print(f"좋아요 토글 오류: {e}")
-        return False, 500
-
-# 홈페이지 라우트
-@app.route('/')
-def home():
-    return render_template('index.html')
-
-# 로그인 처리 API
-@app.route('/api/login', methods=['POST'])
-def login():
-    token = request.form.get('token', '')
-    
-    if not token:
-        return jsonify({'success': False, 'message': '토큰을 입력해주세요.'})
-    
-    is_valid, user_info = validate_token(token)
-    
-    if not is_valid or not user_info:
-        return jsonify({'success': False, 'message': '유효하지 않은 토큰입니다.'})
-    
-    # 사용자 이름 찾기
-    username = None
-    if 'name' in user_info:
-        username = user_info['name']
-    elif 'user' in user_info and 'username' in user_info['user']:
-        username = user_info['user']['username']
-    elif 'username' in user_info:
-        username = user_info['username']
-    else:
-        username = '인증된 사용자'
-    
-    # 좋아요 목록 가져오기
-    liked_models = get_liked_repos(token)
-    
-    # 세션에 저장
-    session['token'] = token
-    session['username'] = username
-    session['liked_models'] = liked_models
-    
-    return jsonify({
-        'success': True, 
-        'username': username,
-        'liked_models': liked_models
-    })
-
-# 로그아웃 처리 API
-@app.route('/api/logout', methods=['POST'])
-def logout():
-    session.pop('token', None)
-    session.pop('username', None)
-    session.pop('liked_models', None)
-    return jsonify({'success': True})
-
-# URL 목록 가져오기 API
-@app.route('/api/urls', methods=['GET'])
-def get_urls():
-    search_query = request.args.get('search', '').lower()
-    show_only_liked = request.args.get('liked', 'false').lower() == 'true'
+        logger.error(f"수동 확인 오류: {str(e)}")
     
-    liked_models = session.get('liked_models', {})
-    
-    results = []
-    for url in HUGGINGFACE_URLS:
-        title = extract_title(url)
-        model_info = extract_model_info(url)
-        
-        if not model_info:
-            continue
+    # 3. API 결과 확인 페이지 추가 (디버깅용)
+    @app.route('/api/debug-likes', methods=['GET'])
+    def debug_likes():
+        if 'token' not in session:
+            return jsonify({'success': False, 'message': '로그인이 필요합니다.'})
         
-        is_liked = model_info['full_id'] in liked_models
+        headers = {"Authorization": f"Bearer {session['token']}"}
+        results = {}
         
-        # 필터링 적용
-        if show_only_liked and not is_liked:
-            continue
+        for endpoint in ["/api/me/likes", "/api/me/liked-repos", "/api/me/favorites"]:
+            try:
+                response = requests.get(f"https://huggingface.co{endpoint}", headers=headers)
+                results[endpoint] = {
+                    'status': response.status_code,
+                    'ok': response.ok,
+                    'data': response.json() if response.ok else None
+                }
+            except Exception as e:
+                results[endpoint] = {'error': str(e)}
         
-        if search_query and search_query not in url.lower() and search_query not in title.lower():
-            continue
-        
-        results.append({
-            'url': url,
-            'title': title,
-            'model_info': model_info,
-            'is_liked': is_liked
-        })
+        return jsonify(results)
     
-    return jsonify(results)
+    # 좋아요 상태가 없는 경우 빈 객체 반환
+    logger.debug("좋아요 목록 없음, 빈 객체 반환")
+    return liked_models
 
-# 좋아요 토글 API
-@app.route('/api/toggle-like', methods=['POST'])
-def api_toggle_like():
-    if 'token' not in session:
-        return jsonify({'success': False, 'message': '로그인이 필요합니다.'})
-    
-    data = request.json
-    url = data.get('url')
-    current_liked = data.get('currentLiked', False)
-    
-    if not url:
-        return jsonify({'success': False, 'message': 'URL이 필요합니다.'})
-    
-    model_info = extract_model_info(url)
-    if not model_info:
-        return jsonify({'success': False, 'message': '유효하지 않은 URL입니다.'})
-    
-    success, status_code = toggle_like(
-        session['token'], 
-        model_info['type'], 
-        model_info['owner'], 
-        model_info['repo'], 
-        current_liked
-    )
-    
-    liked_models = session.get('liked_models', {})
-    
-    if success:
-        # 세션의 좋아요 상태 업데이트
-        if current_liked:
-            if model_info['full_id'] in liked_models:
-                del liked_models[model_info['full_id']]
-        else:
-            liked_models[model_info['full_id']] = True
+# 메인 앱용 플래그를 추가해 디버깅 엔드포인트 추가
+def add_debug_endpoints(app):
+    @app.route('/api/debug-likes', methods=['GET'])
+    def debug_likes():
+        if 'token' not in session:
+            return jsonify({'success': False, 'message': '로그인이 필요합니다.'})
         
-        session['liked_models'] = liked_models
+        headers = {"Authorization": f"Bearer {session['token']}"}
+        results = {}
         
-        return jsonify({
-            'success': True, 
-            'new_state': not current_liked,
-            'message': f"{'좋아요 취소' if current_liked else '좋아요'} 성공"
-        })
-    else:
-        return jsonify({
-            'success': False, 
-            'message': f"API 오류 (상태 코드: {status_code})"
-        })
-
-# 세션 상태 확인 API
-@app.route('/api/session-status', methods=['GET'])
-def session_status():
-    return jsonify({
-        'logged_in': 'token' in session,
-        'username': session.get('username'),
-        'liked_count': len(session.get('liked_models', {}))
-    })
-
-if __name__ == '__main__':
-    # templates 폴더 생성
-    os.makedirs('templates', exist_ok=True)
-    
-    # index.html 파일 생성
-    with open('templates/index.html', 'w', encoding='utf-8') as f:
-        f.write('''
-<!DOCTYPE html>
-<html lang="ko">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>Hugging Face URL 카드 리스트</title>
-  <style>
-    body {
-      font-family: Arial, sans-serif;
-      line-height: 1.6;
-      margin: 0;
-      padding: 0;
-      color: #333;
-    }
-    
-    .container {
-      max-width: 1200px;
-      margin: 0 auto;
-      padding: 1rem;
-    }
-    
-    .header {
-      background-color: #f0f0f0;
-      padding: 1rem;
-      border-radius: 5px;
-      margin-bottom: 1rem;
-    }
-    
-    .user-controls {
-      display: flex;
-      justify-content: space-between;
-      align-items: center;
-      flex-wrap: wrap;
-    }
-    
-    .filter-controls {
-      background-color: #f8f9fa;
-      padding: 1rem;
-      border-radius: 5px;
-      margin-bottom: 1rem;
-    }
-    
-    input[type="password"],
-    input[type="text"] {
-      padding: 0.5rem;
-      border: 1px solid #ccc;
-      border-radius: 4px;
-      margin-right: 5px;
-    }
-    
-    button {
-      padding: 0.5rem 1rem;
-      background-color: #4CAF50;
-      color: white;
-      border: none;
-      border-radius: 4px;
-      cursor: pointer;
-    }
-    
-    button:hover {
-      background-color: #45a049;
-    }
-    
-    button.logout {
-      background-color: #f44336;
-    }
-    
-    button.logout:hover {
-      background-color: #d32f2f;
-    }
-    
-    .token-help {
-      margin-top: 0.5rem;
-      font-size: 0.8rem;
-      color: #666;
-    }
-    
-    .token-help a {
-      color: #4CAF50;
-      text-decoration: none;
-    }
-    
-    .token-help a:hover {
-      text-decoration: underline;
-    }
-    
-    .cards-container {
-      display: flex;
-      flex-wrap: wrap;
-      gap: 1rem;
-    }
-    
-    .card {
-      border: 1px solid #ccc;
-      border-radius: 5px;
-      padding: 1rem;
-      width: 300px;
-      box-shadow: 2px 2px 8px rgba(0,0,0,0.1);
-      position: relative;
-      background-color: #f9f9f9;
-    }
-    
-    .card a {
-      text-decoration: none;
-      color: #333;
-      word-break: break-all;
-    }
-    
-    .like-button {
-      position: absolute;
-      top: 1rem;
-      right: 1rem;
-      border: none;
-      background: transparent;
-      font-size: 1.5rem;
-      cursor: pointer;
-      transition: color 0.2s;
-    }
-    
-    .like-button.liked {
-      color: red;
-    }
-    
-    .like-button.not-liked {
-      color: white;
-      -webkit-text-stroke: 1px #333;
-    }
-    
-    .status-message {
-      padding: 1rem;
-      border-radius: 4px;
-      margin-bottom: 1rem;
-      display: none;
-    }
-    
-    .success {
-      background-color: #dff0d8;
-      color: #3c763d;
-    }
-    
-    .error {
-      background-color: #f2dede;
-      color: #a94442;
-    }
-    
-    .loading {
-      position: fixed;
-      top: 0;
-      left: 0;
-      right: 0;
-      bottom: 0;
-      background-color: rgba(255, 255, 255, 0.7);
-      display: none;
-      justify-content: center;
-      align-items: center;
-      z-index: 1000;
-      font-size: 1.5rem;
-    }
-    
-    .login-section {
-      margin-top: 1rem;
-    }
-    
-    .logged-in-section {
-      display: none;
-      margin-top: 1rem;
-    }
-    
-    @media (max-width: 768px) {
-      .user-controls {
-        flex-direction: column;
-        align-items: flex-start;
-      }
-      
-      .user-controls > div {
-        margin-bottom: 1rem;
-      }
-      
-      .card {
-        width: 100%;
-      }
-    }
-  </style>
-</head>
-<body>
-  <div class="container">
-    <div class="header">
-      <div class="user-controls">
-        <div>
-          <span>허깅페이스 계정: </span>
-          <span id="currentUser">로그인되지 않음</span>
-        </div>
-        
-        <div id="loginSection" class="login-section">
-          <input type="password" id="tokenInput" placeholder="허깅페이스 API 토큰 입력" />
-          <button id="loginButton">인증하기</button>
-          <div class="token-help">
-            API 토큰은 <a href="https://huggingface.co/settings/tokens" target="_blank">허깅페이스 토큰 페이지</a>에서 생성할 수 있습니다.
-          </div>
-        </div>
-        
-        <div id="loggedInSection" class="logged-in-section">
-          <button id="logoutButton" class="logout">로그아웃</button>
-        </div>
-      </div>
-    </div>
-    
-    <div class="filter-controls">
-      <label>
-        <input type="checkbox" id="showOnlyLiked" />
-        내가 좋아요한 URL만 보기
-      </label>
-      <label style="margin-left: 1rem;">
-        <input type="text" id="searchInput" placeholder="URL 또는 제목으로 검색" style="width: 250px;" />
-      </label>
-    </div>
-    
-    <div id="statusMessage" class="status-message"></div>
-    
-    <div id="loadingIndicator" class="loading">처리 중...</div>
-    
-    <div id="cardsContainer" class="cards-container"></div>
-  </div>
-  
-  <script>
-    // DOM 요소 참조
-    const elements = {
-      tokenInput: document.getElementById('tokenInput'),
-      loginButton: document.getElementById('loginButton'),
-      logoutButton: document.getElementById('logoutButton'),
-      currentUser: document.getElementById('currentUser'),
-      cardsContainer: document.getElementById('cardsContainer'),
-      loadingIndicator: document.getElementById('loadingIndicator'),
-      statusMessage: document.getElementById('statusMessage'),
-      showOnlyLiked: document.getElementById('showOnlyLiked'),
-      searchInput: document.getElementById('searchInput'),
-      loginSection: document.getElementById('loginSection'),
-      loggedInSection: document.getElementById('loggedInSection')
-    };
-    
-    // 애플리케이션 상태
-    const state = {
-      username: null,
-      likedModels: {},
-      isLoading: false
-    };
-    
-    // 로딩 상태 표시 함수
-    function setLoading(isLoading) {
-      state.isLoading = isLoading;
-      elements.loadingIndicator.style.display = isLoading ? 'flex' : 'none';
-    }
-    
-    // 상태 메시지 표시 함수
-    function showMessage(message, isError = false) {
-      elements.statusMessage.textContent = message;
-      elements.statusMessage.className = `status-message ${isError ? 'error' : 'success'}`;
-      elements.statusMessage.style.display = 'block';
-      
-      // 3초 후 메시지 사라짐
-      setTimeout(() => {
-        elements.statusMessage.style.display = 'none';
-      }, 3000);
-    }
-    
-    // API 오류 처리 함수
-    async function handleApiResponse(response) {
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`API 오류 (${response.status}): ${errorText}`);
-      }
-      return response.json();
-    }
-    
-    // 세션 상태 확인
-    async function checkSessionStatus() {
-      try {
-        const response = await fetch('/api/session-status');
-        const data = await handleApiResponse(response);
+        for endpoint in ["/api/me/likes", "/api/me/liked-repos", "/api/me/favorites"]:
+            try:
+                response = requests.get(f"https://huggingface.co{endpoint}", headers=headers)
+                results[endpoint] = {
+                    'status': response.status_code,
+                    'ok': response.ok
+                }
+                
+                # 성공한 경우에만 데이터 추가
+                if response.ok:
+                    try:
+                        results[endpoint]['data'] = response.json()
+                    except Exception as e:
+                        results[endpoint]['parse_error'] = str(e)
+            except Exception as e:
+                results[endpoint] = {'error': str(e)}
         
-        if (data.logged_in) {
-          state.username = data.username;
-          elements.currentUser.textContent = data.username;
-          elements.loginSection.style.display = 'none';
-          elements.loggedInSection.style.display = 'block';
-          
-          // URL 목록 로드
-          loadUrls();
+        # 현재 세션에 저장된 좋아요 목록 반환
+        results['current_session_likes'] = {
+            'count': len(session.get('liked_models', {})),
+            'items': list(session.get('liked_models', {}).keys())
         }
-      } catch (error) {
-        console.error('세션 상태 확인 오류:', error);
-      }
-    }
-    
-    // 로그인 처리
-    async function login(token) {
-      if (!token.trim()) {
-        showMessage('토큰을 입력해주세요.', true);
-        return;
-      }
-      
-      setLoading(true);
-      
-      try {
-        const formData = new FormData();
-        formData.append('token', token);
-        
-        const response = await fetch('/api/login', {
-          method: 'POST',
-          body: formData
-        });
         
-        const data = await handleApiResponse(response);
-        
-        if (data.success) {
-          state.username = data.username;
-          state.likedModels = data.liked_models || {};
-          
-          elements.currentUser.textContent = state.username;
-          elements.loginSection.style.display = 'none';
-          elements.loggedInSection.style.display = 'block';
-          
-          showMessage(`${state.username}님으로 로그인되었습니다.`);
-          
-          // URL 목록 로드
-          loadUrls();
-        } else {
-          showMessage(data.message || '로그인에 실패했습니다.', true);
-        }
-      } catch (error) {
-        console.error('로그인 오류:', error);
-        showMessage(`로그인 오류: ${error.message}`, true);
-      } finally {
-        setLoading(false);
-      }
-    }
+        return jsonify(results)
     
-    // 로그아웃 처리
-    async function logout() {
-      setLoading(true);
-      
-      try {
-        const response = await fetch('/api/logout', {
-          method: 'POST'
-        });
+    @app.route('/api/debug-urls', methods=['GET'])
+    def debug_urls():
+        # 모델 정보 추출 디버깅
+        from urllib.parse import urlparse
         
-        const data = await handleApiResponse(response);
+        test_urls = [
+            "https://huggingface.co/spaces/ginipick/Tech_Hangman_Game",
+            "https://huggingface.co/models/meta/llama-2",
+            "https://huggingface.co/meta/llama-2"
+        ]
         
-        if (data.success) {
-          state.username = null;
-          state.likedModels = {};
-          
-          elements.currentUser.textContent = '로그인되지 않음';
-          elements.tokenInput.value = '';
-          elements.loginSection.style.display = 'block';
-          elements.loggedInSection.style.display = 'none';
-          
-          showMessage('로그아웃되었습니다.');
-          
-          // 카드 초기화
-          elements.cardsContainer.innerHTML = '';
-        }
-      } catch (error) {
-        console.error('로그아웃 오류:', error);
-        showMessage(`로그아웃 오류: ${error.message}`, true);
-      } finally {
-        setLoading(false);
-      }
-    }
-    
-    // URL 목록 로드
-    async function loadUrls() {
-      setLoading(true);
-      
-      try {
-        const showOnlyLiked = elements.showOnlyLiked.checked;
-        const searchText = elements.searchInput.value;
+        results = {}
         
-        const response = await fetch(`/api/urls?liked=${showOnlyLiked}&search=${encodeURIComponent(searchText)}`);
-        const urls = await handleApiResponse(response);
+        for url in test_urls:
+            try:
+                parsed = urlparse(url)
+                path_parts = parsed.path.split('/')
+                path_parts = [p for p in path_parts if p]  # 빈 문자열 제거
+                
+                result = {
+                    'parsed_url': {
+                        'scheme': parsed.scheme,
+                        'netloc': parsed.netloc,
+                        'path': parsed.path,
+                        'path_parts': path_parts
+                    }
+                }
+                
+                # 경로 파싱
+                if len(path_parts) >= 2:
+                    if path_parts[0] == 'spaces' or path_parts[0] == 'models':
+                        result['extract'] = {
+                            'type': path_parts[0],
+                            'owner': path_parts[1],
+                            'repo': path_parts[2] if len(path_parts) > 2 else None,
+                            'full_id': f"{path_parts[1]}/{path_parts[2]}" if len(path_parts) > 2 else f"{path_parts[1]}"
+                        }
+                    else:
+                        result['extract'] = {
+                            'type': 'models',  # 기본값
+                            'owner': path_parts[0],
+                            'repo': path_parts[1] if len(path_parts) > 1 else None,
+                            'full_id': f"{path_parts[0]}/{path_parts[1]}" if len(path_parts) > 1 else f"{path_parts[0]}"
+                        }
+                
+                results[url] = result
+            except Exception as e:
+                results[url] = {'error': str(e)}
         
-        renderCards(urls);
-      } catch (error) {
-        console.error('URL 목록 로드 오류:', error);
-        showMessage(`URL 로드 오류: ${error.message}`, true);
-      } finally {
-        setLoading(false);
-      }
-    }
-    
-    // 좋아요 토글
-    async function toggleLike(url, button, currentLiked) {
-      if (!state.username) {
-        showMessage('좋아요를 하려면 허깅페이스 API 토큰으로 인증이 필요합니다.', true);
-        return;
-      }
-      
-      setLoading(true);
-      
-      try {
-        const response = await fetch('/api/toggle-like', {
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json'
-          },
-          body: JSON.stringify({
-            url: url,
-            currentLiked: currentLiked
-          })
-        });
+        return jsonify(results)
+
+# 이 스크립트가 직접 실행되면 테스트 서버를 시작
+if __name__ == '__main__':
+    test_app = Flask(__name__)
+    test_app.secret_key = os.urandom(24)
+    
+    # 세션 쿠키 설정
+    test_app.config['SESSION_COOKIE_SECURE'] = False  # HTTPS 없이도 작동
+    test_app.config['SESSION_COOKIE_HTTPONLY'] = True
+    
+    add_debug_endpoints(test_app)
+    
+    @test_app.route('/')
+    def home():
+        return '''
+        <h1>허깅페이스 좋아요 디버거</h1>
+        <p>다음 엔드포인트로 접속하세요:</p>
+        <ul>
+            <li><a href="/login-form">로그인 페이지</a></li>
+            <li><a href="/api/debug-likes">좋아요 API 디버그 (로그인 필요)</a></li>
+            <li><a href="/api/debug-urls">URL 파싱 디버그</a></li>
+        </ul>
+        '''
+    
+    @test_app.route('/login-form')
+    def login_form():
+        return '''
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <title>토큰 로그인</title>
+            <style>
+                body { font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto; padding: 20px; }
+                input { width: 100%; padding: 8px; margin: 10px 0; }
+                button { padding: 10px 15px; background: #4CAF50; color: white; border: none; cursor: pointer; }
+                .result { margin-top: 20px; padding: 10px; border: 1px solid #ddd; display: none; }
+                pre { background: #f5f5f5; padding: 10px; overflow-x: auto; }
+            </style>
+        </head>
+        <body>
+            <h1>허깅페이스 토큰 테스트</h1>
+            <p>허깅페이스 API 토큰을 입력하세요:</p>
+            
+            <input type="password" id="tokenInput" placeholder="API 토큰" />
+            <button id="loginBtn">로그인</button>
+            
+            <div id="result" class="result">
+                <h3>결과</h3>
+                <pre id="resultContent"></pre>
+            </div>
+            
+            <script>
+                const loginBtn = document.getElementById('loginBtn');
+                const tokenInput = document.getElementById('tokenInput');
+                const result = document.getElementById('result');
+                const resultContent = document.getElementById('resultContent');
+                
+                loginBtn.addEventListener('click', async () => {
+                    const token = tokenInput.value.trim();
+                    if (!token) {
+                        alert('토큰을 입력하세요');
+                        return;
+                    }
+                    
+                    try {
+                        const formData = new FormData();
+                        formData.append('token', token);
+                        
+                        const response = await fetch('/api/login-test', {
+                            method: 'POST',
+                            body: formData
+                        });
+                        
+                        const data = await response.json();
+                        result.style.display = 'block';
+                        resultContent.textContent = JSON.stringify(data, null, 2);
+                        
+                        if (data.success) {
+                            // 성공 시 좋아요 목록 페이지로 이동
+                            setTimeout(() => {
+                                window.location.href = '/api/debug-likes';
+                            }, 2000);
+                        }
+                    } catch (error) {
+                        result.style.display = 'block';
+                        resultContent.textContent = `오류: ${error.message}`;
+                    }
+                });
+            </script>
+        </body>
+        </html>
+        '''
+    
+    @test_app.route('/api/login-test', methods=['POST'])
+    def login_test():
+        token = request.form.get('token', '')
         
-        const data = await handleApiResponse(response);
+        if not token:
+            return jsonify({'success': False, 'message': '토큰을 입력해주세요.'})
         
-        if (data.success) {
-          if (currentLiked) {
-            button.classList.remove('liked');
-            button.classList.add('not-liked');
-          } else {
-            button.classList.add('liked');
-            button.classList.remove('not-liked');
-          }
-          
-          showMessage(data.message);
-          
-          // 필터링된 경우 목록 다시 로드
-          if (elements.showOnlyLiked.checked) {
-            loadUrls();
-          }
-        } else {
-          showMessage(data.message, true);
-        }
-      } catch (error) {
-        console.error('좋아요 토글 오류:', error);
-        showMessage(`좋아요 처리 오류: ${error.message}`, true);
-      } finally {
-        setLoading(false);
-      }
-    }
-    
-    // 카드 렌더링
-    function renderCards(urls) {
-      elements.cardsContainer.innerHTML = '';
-      
-      if (!urls || urls.length === 0) {
-        const noResultsMsg = document.createElement('p');
-        noResultsMsg.textContent = '표시할 URL이 없습니다.';
-        noResultsMsg.style.padding = '1rem';
-        noResultsMsg.style.fontStyle = 'italic';
-        elements.cardsContainer.appendChild(noResultsMsg);
-        return;
-      }
-      
-      urls.forEach(item => {
-        const { url, title, is_liked } = item;
+        session['token'] = token
         
-        // 카드 생성
-        const card = document.createElement('div');
-        card.className = 'card';
+        # 사용자 정보 가져오기
+        user_info = None
+        for endpoint in ["https://huggingface.co/api/whoami-v2", "https://huggingface.co/api/whoami"]:
+            try:
+                headers = {"Authorization": f"Bearer {token}"}
+                response = requests.get(endpoint, headers=headers)
+                
+                if response.ok:
+                    user_info = response.json()
+                    break
+            except Exception as e:
+                logger.error(f"사용자 정보 가져오기 오류: {str(e)}")
         
-        // 제목
-        const titleEl = document.createElement('h3');
-        titleEl.textContent = title;
-        card.appendChild(titleEl);
+        if not user_info:
+            return jsonify({'success': False, 'message': '유효하지 않은 토큰입니다.'})
         
-        // URL 링크
-        const linkEl = document.createElement('a');
-        linkEl.href = url;
-        linkEl.textContent = url;
-        linkEl.target = '_blank';
-        card.appendChild(linkEl);
+        # 사용자 이름 찾기
+        username = None
+        if 'name' in user_info:
+            username = user_info['name']
+        elif 'user' in user_info and 'username' in user_info['user']:
+            username = user_info['user']['username']
+        elif 'username' in user_info:
+            username = user_info['username']
+        else:
+            username = '인증된 사용자'
         
-        // 좋아요 버튼 (♥ 아이콘)
-        const likeBtn = document.createElement('button');
-        likeBtn.className = `like-button ${is_liked ? 'liked' : 'not-liked'}`;
-        likeBtn.textContent = '♥';
+        session['username'] = username
         
-        likeBtn.addEventListener('click', function(e) {
-          e.preventDefault();
-          toggleLike(url, likeBtn, is_liked);
-        });
-        card.appendChild(likeBtn);
+        # 좋아요 목록 가져오기
+        liked_models = get_liked_repos(token)
+        session['liked_models'] = liked_models
         
-        // 카드 추가
-        elements.cardsContainer.appendChild(card);
-      });
-    }
-    
-    // 이벤트 리스너 설정
-    elements.loginButton.addEventListener('click', () => {
-      login(elements.tokenInput.value);
-    });
-    
-    elements.logoutButton.addEventListener('click', logout);
-    
-    // 엔터 키로 로그인 가능하게
-    elements.tokenInput.addEventListener('keypress', (event) => {
-      if (event.key === 'Enter') {
-        login(elements.tokenInput.value);
-      }
-    });
-    
-    // 필터링 이벤트 리스너
-    elements.showOnlyLiked.addEventListener('change', loadUrls);
-    elements.searchInput.addEventListener('input', () => {
-      // 입력 지연 처리 (타이핑할 때마다 API 호출 방지)
-      clearTimeout(state.searchTimeout);
-      state.searchTimeout = setTimeout(loadUrls, 300);
-    });
-    
-    // 초기화
-    checkSessionStatus();
-  </script>
-</body>
-</html>
-''')
+        return jsonify({
+            'success': True,
+            'username': username,
+            'liked_models_count': len(liked_models),
+            'liked_models_sample': list(liked_models.keys())[:5] if liked_models else []
+        })
     
-    # 허깅페이스 스페이스에서는 7860 포트 사용
-    app.run(host='0.0.0.0', port=7860)
+    # 디버깅 서버 실행
+    logger.info("디버깅 서버 시작 (포트 7860)")
+    test_app.run(host='0.0.0.0', port=7860, debug=True)