Update app.py

app.py

@@ -2,17 +2,17 @@
 # -*- coding: utf-8 -*-
 
 import os
-import io
-from flask import Flask, request, Response, render_template_string, jsonify, session
+from flask import Flask, request, Response, render_template_string, jsonify, redirect, url_for, make_response
 import hmac
 import hashlib
 import json
-from urllib.parse import unquote, parse_qs
+from urllib.parse import unquote, parse_qs, quote
 import time
 from datetime import datetime
 import logging
+import threading
 from huggingface_hub import HfApi, hf_hub_download, list_repo_files
-from huggingface_hub.utils import RepositoryNotFoundError, EntryNotFoundError
+from huggingface_hub.utils import RepositoryNotFoundError, HfHubHTTPError
 from werkzeug.utils import secure_filename
 
 # --- Configuration ---
@@ -21,26 +21,18 @@ HOST = '0.0.0.0'
 PORT = 7860
 
 # Hugging Face Settings
-REPO_ID = os.getenv("HF_REPO_ID", "Eluza133/Z1e1u")
+REPO_ID = "Eluza133/Z1e1u"
 HF_UPLOAD_FOLDER = "uploads" # Base folder within the HF repo
 HF_TOKEN_WRITE = os.getenv("HF_TOKEN_WRITE") # Token with write access
-HF_TOKEN_READ = os.getenv("HF_TOKEN_READ", HF_TOKEN_WRITE) # Read token (can be same as write)
+HF_TOKEN_READ = os.getenv("HF_TOKEN_READ") # Token with read access (can be same as write)
+
+# File Upload Settings
+MAX_FILES_PER_UPLOAD = 20
 
 app = Flask(__name__)
 logging.basicConfig(level=logging.INFO)
-app.secret_key = os.getenv("FLASK_SECRET_KEY", os.urandom(24)) # Use env var or random
-
-# --- Hugging Face API Initialization ---
-hf_api = None
-if HF_TOKEN_WRITE:
-    hf_api = HfApi(token=HF_TOKEN_WRITE)
-    logging.info(f"Hugging Face API initialized for repo: {REPO_ID} with Write Token.")
-elif HF_TOKEN_READ:
-    hf_api = HfApi(token=HF_TOKEN_READ)
-    logging.info(f"Hugging Face API initialized for repo: {REPO_ID} with Read-Only Token.")
-else:
-    logging.warning("HF_TOKEN_WRITE or HF_TOKEN_READ not set. Hugging Face operations will fail.")
-
+app.secret_key = os.urandom(24)
+hf_api = HfApi()
 
 # --- Telegram Verification ---
 def verify_telegram_data(init_data_str):
@@ -49,8 +41,8 @@ def verify_telegram_data(init_data_str):
         received_hash = parsed_data.pop('hash', [None])[0]
 
         if not received_hash:
-            logging.warning("Verification failed: Hash missing.")
-            return None, False
+            logging.warning("Verification failed: Hash missing")
+            return None, False, "Хэш отсутствует"
 
         data_check_list = []
         for key, value in sorted(parsed_data.items()):
@@ -63,40 +55,38 @@ def verify_telegram_data(init_data_str):
         if calculated_hash == received_hash:
             auth_date = int(parsed_data.get('auth_date', [0])[0])
             current_time = int(time.time())
-            # Allow data up to 24 hours old, adjust as needed
+            # Allow data up to 24 hours old, adjust if needed
             if current_time - auth_date > 86400:
-                 logging.warning(f"Verification warning: Telegram InitData is older than 24 hours (Auth Date: {auth_date}, Current: {current_time}).")
-                 # Decide if this should be a failure: return parsed_data, False
-            return parsed_data, True
+                 logging.warning(f"Telegram InitData is older than 24 hours (Auth Date: {auth_date}, Current: {current_time}). Allowing.")
+                 # return parsed_data, False, "Данные авторизации устарели" # Uncomment to enforce stricter timeout
+
+            return parsed_data, True, "Верификация успешна"
         else:
-            logging.warning(f"Verification failed: Hash mismatch. Calculated: {calculated_hash}, Received: {received_hash}")
-            return parsed_data, False
+            logging.warning(f"Verification failed. Calculated: {calculated_hash}, Received: {received_hash}")
+            return parsed_data, False, "Неверный хэш"
     except Exception as e:
-        logging.error(f"Error verifying Telegram data: {e}", exc_info=True)
-        return None, False
+        logging.error(f"Error verifying Telegram data: {e}")
+        return None, False, f"Ошибка верификации: {e}"
 
-def get_user_id_from_initdata(init_data_str):
-    parsed_data, is_valid = verify_telegram_data(init_data_str)
-    if not is_valid or not parsed_data or 'user' not in parsed_data:
+def get_user_id_from_init_data(init_data_str):
+    parsed_data, is_valid, _ = verify_telegram_data(init_data_str)
+    if not is_valid:
         return None
 
+    user_data_json = parsed_data.get('user', [None])[0]
+    if not user_data_json:
+        return None
     try:
-        user_json_str = unquote(parsed_data['user'][0])
-        user_info_dict = json.loads(user_json_str)
-        user_id = user_info_dict.get('id')
-        if user_id:
-            return str(user_id) # Return as string
-        else:
-            logging.error("User ID not found in parsed user data.")
-            return None
-    except Exception as e:
-        logging.error(f"Could not parse user JSON or get ID: {e}", exc_info=True)
+        user_info = json.loads(unquote(user_data_json))
+        return user_info.get('id')
+    except (json.JSONDecodeError, TypeError) as e:
+        logging.error(f"Could not parse user data from initData: {e}")
         return None
 
 # --- HTML Templates ---
 TEMPLATE = """
 <!DOCTYPE html>
-<html lang="en">
+<html lang="ru">
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0, shrink-to-fit=no, user-scalable=no, viewport-fit=cover">
@@ -104,7 +94,7 @@ TEMPLATE = """
     <script src="https://telegram.org/js/telegram-web-app.js"></script>
     <link rel="preconnect" href="https://fonts.googleapis.com">
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
-    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap" rel="stylesheet">
     <style>
         :root {
             --tg-theme-bg-color: {{ theme.bg_color | default('#ffffff') }};
@@ -114,473 +104,542 @@ TEMPLATE = """
             --tg-theme-button-color: {{ theme.button_color | default('#2481cc') }};
             --tg-theme-button-text-color: {{ theme.button_text_color | default('#ffffff') }};
             --tg-theme-secondary-bg-color: {{ theme.secondary_bg_color | default('#f1f1f1') }};
-            --tg-color-scheme: {{ color_scheme | default('light') }};
-
-            --bg-color: var(--tg-theme-bg-color);
-            --text-color: var(--tg-theme-text-color);
-            --hint-color: var(--tg-theme-hint-color);
-            --button-bg: var(--tg-theme-button-color);
-            --button-text: var(--tg-theme-button-text-color);
-            --secondary-bg: var(--tg-theme-secondary-bg-color);
-            --border-color: var(--tg-theme-hint-color);
-            --link-color: var(--tg-theme-link-color);
-            --error-color: #dc3545;
-            --success-color: #198754;
-            --font-family: 'Inter', sans-serif;
             --border-radius: 12px;
             --padding: 16px;
-        }
-
-        [data-theme="dark"] {
-             --bg-color: #121212;
-             --text-color: #ffffff;
-             --hint-color: #aaaaaa;
-             --link-color: #62bcf9;
-             --button-bg: #31a5f5;
-             --button-text: #ffffff;
-             --secondary-bg: #1e1e1e;
-             --border-color: #333333;
+            --gap: 16px;
+            --font-family: 'Inter', -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+            --shadow-color: rgba(0, 0, 0, 0.1);
         }
 
         * { box-sizing: border-box; margin: 0; padding: 0; }
-        html {
-            background-color: var(--bg-color);
-            color-scheme: var(--tg-color-scheme);
-        }
+
         body {
             font-family: var(--font-family);
-            background-color: var(--bg-color);
-            color: var(--text-color);
+            background-color: var(--tg-theme-bg-color);
+            color: var(--tg-theme-text-color);
             padding: var(--padding);
             overscroll-behavior-y: none;
-            line-height: 1.6;
-            visibility: hidden; /* Hide until ready */
+            -webkit-font-smoothing: antialiased;
+            -moz-osx-font-smoothing: grayscale;
+            visibility: hidden;
             min-height: 100vh;
         }
+
         .container {
             max-width: 700px;
             margin: 0 auto;
             display: flex;
             flex-direction: column;
-            gap: calc(var(--padding) * 1.5);
+            gap: calc(var(--gap) * 1.5);
         }
-        h1 {
+
+        .header {
             text-align: center;
-            font-size: 1.8em;
+            margin-bottom: var(--gap);
+        }
+
+        .header h1 {
+            font-size: 2em;
             font-weight: 700;
-            color: var(--link-color);
-            margin-bottom: var(--padding);
+            margin-bottom: 0.2em;
+            color: var(--tg-theme-text-color);
+        }
+
+        .header p {
+            font-size: 1em;
+            color: var(--tg-theme-hint-color);
         }
+
         .upload-section, .files-section {
-            background-color: var(--secondary-bg);
+            background-color: var(--tg-theme-secondary-bg-color);
             border-radius: var(--border-radius);
             padding: var(--padding);
-            border: 1px solid var(--border-color);
+            box-shadow: 0 4px 15px var(--shadow-color);
+            border: 1px solid rgba(0,0,0,0.05);
         }
-        h2 {
-            font-size: 1.3em;
+
+        .section-title {
+            font-size: 1.5em;
             font-weight: 600;
-            margin-bottom: var(--padding);
-            border-bottom: 1px solid var(--border-color);
-            padding-bottom: 8px;
+            margin-bottom: var(--gap);
+            color: var(--tg-theme-text-color);
+            display: flex;
+            align-items: center;
+            gap: 8px;
         }
-        .file-input-wrapper {
-            position: relative;
-            overflow: hidden;
-            display: inline-block;
-            border: 2px dashed var(--hint-color);
+        .section-title .icon { font-size: 1.2em; opacity: 0.8; }
+        .icon-upload::before { content: '☁️'; }
+        .icon-files::before { content: '📁'; }
+        .icon-link::before { content: '🔗'; }
+        .icon-image::before { content: '🖼️'; }
+        .icon-video::before { content: '🎬'; }
+        .icon-audio::before { content: '🎵'; }
+        .icon-doc::before { content: '📄'; }
+        .icon-archive::before { content: '📦'; }
+        .icon-generic::before { content: '❔'; }
+
+
+        #upload-form label {
+            display: block;
+            padding: 12px 20px;
+            background-color: var(--tg-theme-button-color);
+            color: var(--tg-theme-button-text-color);
             border-radius: var(--border-radius);
-            padding: var(--padding);
-            text-align: center;
-            cursor: pointer;
-            transition: border-color 0.3s ease;
-            width: 100%;
-            margin-bottom: var(--padding);
-        }
-        .file-input-wrapper:hover {
-            border-color: var(--link-color);
-        }
-        .file-input-wrapper input[type=file] {
-            position: absolute;
-            left: 0; top: 0; opacity: 0;
-            width: 100%; height: 100%;
             cursor: pointer;
-        }
-        .file-input-label {
-            color: var(--hint-color);
+            text-align: center;
             font-weight: 500;
+            margin-bottom: var(--gap);
+            transition: background-color 0.2s ease;
         }
-        .file-input-label span {
-            display: block;
-            font-size: 1.5em;
-            margin-bottom: 8px;
+        #upload-form label:hover {
+             filter: brightness(1.1);
         }
+
+
+        #file-input { display: none; }
+
         #file-list-preview {
+            margin-bottom: var(--gap);
             font-size: 0.9em;
-            color: var(--text-color);
-            margin-top: 10px;
-            max-height: 100px;
-            overflow-y: auto;
-            text-align: left;
-        }
-        #file-list-preview div {
-             padding: 2px 0;
+            color: var(--tg-theme-hint-color);
+        }
+         #file-list-preview div {
+             padding: 5px 0;
              white-space: nowrap;
              overflow: hidden;
              text-overflow: ellipsis;
-        }
+         }
+
         .btn {
-            display: block; width: 100%;
-            padding: 12px var(--padding); border-radius: var(--border-radius);
-            background: var(--button-bg); color: var(--button-text);
-            text-decoration: none; font-weight: 600;
-            border: none; cursor: pointer;
-            transition: background-color 0.2s ease;
-            font-size: 1em; text-align: center;
-        }
-        .btn:hover {
-            opacity: 0.9;
+            display: block; /* Make button full width */
+            width: 100%;
+            padding: 12px 20px;
+            border: none;
+            background: var(--tg-theme-button-color);
+            color: var(--tg-theme-button-text-color);
+            font-size: 1em;
+            font-weight: 600;
+            border-radius: var(--border-radius);
+            cursor: pointer;
+            transition: all 0.2s ease;
+            text-align: center;
         }
+
         .btn:disabled {
-            background-color: var(--hint-color);
+            background-color: var(--tg-theme-hint-color);
             cursor: not-allowed;
-        }
-        #status-message {
-            margin-top: var(--padding);
-            padding: 10px;
-            border-radius: var(--border-radius);
+            opacity: 0.7;
+        }
+        .btn:not(:disabled):hover {
+            filter: brightness(1.1);
+            transform: translateY(-1px);
+        }
+        .btn .loader {
+             border: 3px solid rgba(255, 255, 255, 0.3);
+             border-radius: 50%;
+             border-top: 3px solid var(--tg-theme-button-text-color);
+             width: 18px;
+             height: 18px;
+             animation: spin 1s linear infinite;
+             display: inline-block;
+             margin-left: 10px;
+             vertical-align: middle;
+         }
+         @keyframes spin { 0% { transform: rotate(0deg); } 100% { transform: rotate(360deg); } }
+
+
+        #upload-status {
+            margin-top: var(--gap);
+            font-size: 0.9em;
             text-align: center;
-            font-weight: 500;
-            display: none; /* Hidden by default */
+            min-height: 1.2em; /* Reserve space */
         }
-        #status-message.success { background-color: var(--success-color); color: white; }
-        #status-message.error { background-color: var(--error-color); color: white; }
-        #status-message.loading { background-color: var(--secondary-bg); color: var(--text-color); border: 1px solid var(--border-color); }
+        .status-success { color: #28a745; } /* Green */
+        .status-error { color: #dc3545; } /* Red */
+        .status-info { color: var(--tg-theme-hint-color); }
 
-        .file-list-container {
+        #user-files-list {
             list-style: none;
             padding: 0;
+            margin: 0;
         }
+
         .file-item {
+            background-color: var(--tg-theme-bg-color);
+            padding: 12px var(--padding);
+            border-radius: calc(var(--border-radius) - 4px);
+            margin-bottom: calc(var(--gap) / 2);
             display: flex;
-            justify-content: space-between;
             align-items: center;
-            padding: 10px;
-            border-bottom: 1px solid var(--border-color);
+            justify-content: space-between;
+            gap: var(--gap);
+            border: 1px solid rgba(0,0,0,0.08);
             transition: background-color 0.2s ease;
         }
-        .file-item:last-child { border-bottom: none; }
-        .file-item:hover { background-color: rgba(128, 128, 128, 0.1); }
+        .file-item:hover {
+            background-color: rgba(0,0,0,0.03);
+        }
+
+        .file-info {
+            display: flex;
+            align-items: center;
+            gap: 10px;
+            overflow: hidden; /* Prevent long names from breaking layout */
+        }
+
+        .file-icon { font-size: 1.4em; opacity: 0.7; }
+
         .file-name {
+            font-weight: 500;
+            white-space: nowrap;
+            overflow: hidden;
+            text-overflow: ellipsis;
             flex-grow: 1;
-            margin-right: 15px;
-            word-break: break-all; /* Wrap long names */
+            color: var(--tg-theme-text-color);
         }
-        .file-link {
-            color: var(--link-color);
+
+        .file-actions a {
+            color: var(--tg-theme-link-color);
             text-decoration: none;
-            font-weight: 500;
-            white-space: nowrap;
+            font-size: 1.5em; /* Larger icon */
+            opacity: 0.8;
+            transition: opacity 0.2s ease;
+            padding: 5px; /* Easier to tap */
         }
-        .file-link:hover { text-decoration: underline; }
-        .loading-files, .no-files {
+        .file-actions a:hover { opacity: 1; }
+
+        #loading-files, #no-files {
             text-align: center;
-            color: var(--hint-color);
+            color: var(--tg-theme-hint-color);
             padding: var(--padding);
-            font-style: italic;
+            font-size: 1em;
         }
-        .loader {
-             border: 4px solid var(--secondary-bg); border-radius: 50%; border-top: 4px solid var(--link-color);
-             width: 20px; height: 20px; animation: spin 1s linear infinite; display: inline-block; margin-left: 10px; vertical-align: middle;
+
+        #error-message {
+             background-color: #f8d7da;
+             color: #721c24;
+             padding: var(--padding);
+             border: 1px solid #f5c6cb;
+             border-radius: var(--border-radius);
+             margin-bottom: var(--gap);
+             text-align: center;
+             display: none; /* Hidden by default */
+        }
+
+        #greeting {
+            text-align: center;
+            color: var(--tg-theme-hint-color);
+            font-size: 0.95em;
+            margin-top: var(--gap);
         }
-        @keyframes spin { 0% { transform: rotate(0deg); } 100% { transform: rotate(360deg); } }
     </style>
 </head>
 <body>
     <div class="container">
-        <h1>☁️ Zeus Cloud</h1>
+        <div class="header">
+            <h1>Zeus Cloud</h1>
+            <p>Ваше персональное облачное хранилище</p>
+        </div>
+
+        <div id="error-message"></div>
 
         <section class="upload-section">
-            <h2>Upload Files</h2>
-            <div class="file-input-wrapper">
-                <input type="file" id="fileInput" multiple accept="*/*">
-                <label for="fileInput" class="file-input-label">
-                    <span>📤</span>
-                    Click or Drag & Drop<br>
-                    (Max 20 files)
-                 </label>
-             </div>
-             <div id="file-list-preview">No files selected.</div>
-             <button id="uploadButton" class="btn" disabled>Upload</button>
-             <div id="status-message"></div>
+            <h2 class="section-title"><span class="icon icon-upload"></span>Загрузить файлы</h2>
+            <form id="upload-form">
+                <label for="file-input">Выбрать файлы (до {{ max_files }} шт.)</label>
+                <input type="file" id="file-input" name="files" multiple accept="*.*">
+                <div id="file-list-preview"></div>
+                <button type="submit" id="upload-button" class="btn" disabled>
+                    <span id="upload-button-text">Выберите файлы для загрузки</span>
+                    <span class="loader" id="upload-loader" style="display: none;"></span>
+                </button>
+                <div id="upload-status"></div>
+            </form>
         </section>
 
         <section class="files-section">
-            <h2>My Files</h2>
-            <ul class="file-list-container" id="myFilesList">
-                <li class="loading-files">Loading files...</li>
-            </ul>
+            <h2 class="section-title"><span class="icon icon-files"></span>Мои файлы</h2>
+            <div id="loading-files">Загрузка списка файлов...</div>
+            <ul id="user-files-list"></ul>
+            <div id="no-files" style="display: none;">У вас пока нет загруженных файлов.</div>
         </section>
 
+        <footer id="greeting">Инициализация...</footer>
+
     </div>
 
     <script>
         const tg = window.Telegram.WebApp;
-        const fileInput = document.getElementById('fileInput');
-        const uploadButton = document.getElementById('uploadButton');
-        const statusMessage = document.getElementById('status-message');
-        const myFilesList = document.getElementById('myFilesList');
-        const fileListPreview = document.getElementById('fileList-preview');
-        let currentUserId = null;
-        let currentInitData = null;
+        const uploadForm = document.getElementById('upload-form');
+        const fileInput = document.getElementById('file-input');
+        const fileListPreview = document.getElementById('file-list-preview');
+        const uploadButton = document.getElementById('upload-button');
+        const uploadButtonText = document.getElementById('upload-button-text');
+        const uploadLoader = document.getElementById('upload-loader');
+        const uploadStatus = document.getElementById('upload-status');
+        const userFilesList = document.getElementById('user-files-list');
+        const loadingFiles = document.getElementById('loading-files');
+        const noFiles = document.getElementById('no-files');
+        const greetingElement = document.getElementById('greeting');
+        const errorMessageDiv = document.getElementById('error-message');
+        const MAX_FILES = {{ max_files }};
+        let isUploading = false;
 
         function applyTheme(themeParams) {
             const root = document.documentElement;
-            const colorScheme = themeParams.color_scheme || 'light';
-            root.dataset.theme = colorScheme;
-            root.style.setProperty('--tg-theme-bg-color', themeParams.bg_color || (colorScheme === 'dark' ? '#121212' : '#ffffff'));
-            root.style.setProperty('--tg-theme-text-color', themeParams.text_color || (colorScheme === 'dark' ? '#ffffff' : '#000000'));
-            root.style.setProperty('--tg-theme-hint-color', themeParams.hint_color || (colorScheme === 'dark' ? '#aaaaaa' : '#999999'));
-            root.style.setProperty('--tg-theme-link-color', themeParams.link_color || (colorScheme === 'dark' ? '#62bcf9' : '#2481cc'));
-            root.style.setProperty('--tg-theme-button-color', themeParams.button_color || (colorScheme === 'dark' ? '#31a5f5' : '#2481cc'));
-            root.style.setProperty('--tg-theme-button-text-color', themeParams.button_text_color || (colorScheme === 'dark' ? '#ffffff' : '#ffffff'));
-            root.style.setProperty('--tg-theme-secondary-bg-color', themeParams.secondary_bg_color || (colorScheme === 'dark' ? '#1e1e1e' : '#f1f1f1'));
-            root.style.setProperty('--tg-color-scheme', colorScheme);
-        }
-
-        function showStatus(message, type = 'loading', duration = null) {
-            statusMessage.textContent = message;
-            statusMessage.className = type; // 'success', 'error', 'loading'
-            statusMessage.style.display = 'block';
-
-             // Add loader only for loading type
-             const loader = statusMessage.querySelector('.loader');
-             if (type === 'loading' && !loader) {
-                 const loaderSpan = document.createElement('span');
-                 loaderSpan.className = 'loader';
-                 statusMessage.appendChild(loaderSpan);
-             } else if (type !== 'loading' && loader) {
-                 loader.remove();
-             }
+            Object.keys(themeParams).forEach(key => {
+                const cssVar = `--tg-theme-${key.replace(/_/g, '-')}`;
+                root.style.setProperty(cssVar, themeParams[key]);
+            });
+             // Update root variables directly for template rendering fallback
+            root.style.setProperty('--tg-theme-bg-color', themeParams.bg_color || '#ffffff');
+            root.style.setProperty('--tg-theme-text-color', themeParams.text_color || '#000000');
+            root.style.setProperty('--tg-theme-hint-color', themeParams.hint_color || '#999999');
+            root.style.setProperty('--tg-theme-link-color', themeParams.link_color || '#2481cc');
+            root.style.setProperty('--tg-theme-button-color', themeParams.button_color || '#2481cc');
+            root.style.setProperty('--tg-theme-button-text-color', themeParams.button_text_color || '#ffffff');
+            root.style.setProperty('--tg-theme-secondary-bg-color', themeParams.secondary_bg_color || '#f1f1f1');
+        }
 
+        function showError(message) {
+            errorMessageDiv.textContent = message;
+            errorMessageDiv.style.display = 'block';
+            if (tg.HapticFeedback) tg.HapticFeedback.notificationOccurred('error');
+        }
 
-            if (duration) {
-                setTimeout(() => {
-                    statusMessage.style.display = 'none';
-                }, duration);
-            }
+        function clearError() {
+            errorMessageDiv.style.display = 'none';
+            errorMessageDiv.textContent = '';
         }
 
-        function hideStatus() {
-             statusMessage.style.display = 'none';
+         function showStatus(message, type = 'info') {
+             uploadStatus.textContent = message;
+             uploadStatus.className = `status-${type}`; // Sets class like status-info, status-success, status-error
+         }
+
+        function getFileIcon(filename) {
+            const extension = filename.split('.').pop().toLowerCase();
+            if (['jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp', 'svg'].includes(extension)) return 'icon-image';
+            if (['mp4', 'avi', 'mov', 'wmv', 'mkv', 'webm'].includes(extension)) return 'icon-video';
+            if (['mp3', 'wav', 'ogg', 'aac', 'flac'].includes(extension)) return 'icon-audio';
+            if (['doc', 'docx', 'pdf', 'txt', 'rtf', 'odt'].includes(extension)) return 'icon-doc';
+            if (['zip', 'rar', '7z', 'tar', 'gz'].includes(extension)) return 'icon-archive';
+            return 'icon-generic'; // Default icon
         }
 
-        async function fetchFiles() {
-            if (!currentInitData) {
-                console.error("Cannot fetch files: initData not available.");
-                myFilesList.innerHTML = '<li class="no-files">Error: Could not verify user.</li>';
-                return;
-            }
-            myFilesList.innerHTML = '<li class="loading-files">Loading files...</li>';
+        async function loadFiles() {
+            loadingFiles.style.display = 'block';
+            userFilesList.innerHTML = '';
+            noFiles.style.display = 'none';
+            clearError();
 
             try {
                 const response = await fetch('/list_files', {
-                    method: 'GET',
-                    headers: {
-                        'X-Telegram-Init-Data': currentInitData,
-                        'Accept': 'application/json'
-                    }
-                });
+                     method: 'POST', // Sending initData securely
+                     headers: {
+                         'Content-Type': 'application/json',
+                         'Accept': 'application/json'
+                     },
+                     body: JSON.stringify({ initData: tg.initData }),
+                 });
 
                 if (!response.ok) {
-                    const errorData = await response.json().catch(() => ({ message: `HTTP error! status: ${response.status}` }));
-                    throw new Error(errorData.message || `Failed to fetch files (${response.status})`);
+                    const errorData = await response.json().catch(() => ({ message: `Ошибка сервера: ${response.status}` }));
+                    throw new Error(errorData.message || `Ошибка загрузки файлов: ${response.status}`);
                 }
 
                 const data = await response.json();
 
                 if (data.status === 'ok') {
-                    displayFiles(data.files);
+                    if (data.files && data.files.length > 0) {
+                        data.files.forEach(file => {
+                            const li = document.createElement('li');
+                            li.className = 'file-item';
+                            const fileIconClass = getFileIcon(file.name);
+                            li.innerHTML = `
+                                <div class="file-info">
+                                    <span class="file-icon ${fileIconClass}"></span>
+                                    <span class="file-name" title="${file.name}">${file.name}</span>
+                                </div>
+                                <div class="file-actions">
+                                    <a href="${file.url}" target="_blank" title="Открыть/Скачать">
+                                        <span class="icon-link"></span>
+                                    </a>
+                                </div>
+                            `;
+                            userFilesList.appendChild(li);
+                        });
+                        noFiles.style.display = 'none';
+                    } else {
+                        noFiles.style.display = 'block';
+                    }
                 } else {
-                    throw new Error(data.message || 'Failed to list files from server.');
+                    throw new Error(data.message || 'Не удалось получить список файлов.');
                 }
-            } catch (error) {
-                console.error('Error fetching files:', error);
-                myFilesList.innerHTML = `<li class="no-files">Error loading files: ${error.message}</li>`;
-            }
-        }
 
-        function displayFiles(files) {
-            myFilesList.innerHTML = ''; // Clear previous list
-            if (!files || files.length === 0) {
-                myFilesList.innerHTML = '<li class="no-files">No files uploaded yet.</li>';
-                return;
+            } catch (error) {
+                console.error('Error loading files:', error);
+                showError(`Не удалось загрузить список файлов: ${error.message}`);
+                noFiles.style.display = 'block'; // Show no files message on error
+            } finally {
+                loadingFiles.style.display = 'none';
             }
-
-            files.sort().forEach(fileInfo => { // Sort alphabetically by path
-                const li = document.createElement('li');
-                li.className = 'file-item';
-
-                const fileNameSpan = document.createElement('span');
-                fileNameSpan.className = 'file-name';
-                // Display only the filename part
-                fileNameSpan.textContent = fileInfo.name.split('/').pop();
-
-                const fileLink = document.createElement('a');
-                fileLink.className = 'file-link';
-                fileLink.href = fileInfo.url;
-                fileLink.textContent = 'Open';
-                fileLink.target = '_blank'; // Open in new tab
-
-                li.appendChild(fileNameSpan);
-                li.appendChild(fileLink);
-                myFilesList.appendChild(li);
-            });
         }
 
         function handleFileSelection() {
             const files = fileInput.files;
+            fileListPreview.innerHTML = ''; // Clear previous preview
             if (files.length === 0) {
-                 fileListPreview.textContent = 'No files selected.';
+                uploadButtonText.textContent = 'Выберите файлы для загрузки';
+                uploadButton.disabled = true;
+            } else if (files.length > MAX_FILES) {
+                 uploadButtonText.textContent = `Слишком много файлов (${files.length})`;
+                 showStatus(`Выбрано ${files.length} файлов. Максимум ${MAX_FILES}.`, 'error');
                  uploadButton.disabled = true;
-            } else if (files.length > 20) {
-                 fileListPreview.textContent = `Error: Too many files selected (${files.length}). Maximum is 20.`;
-                 uploadButton.disabled = true;
-                 tg.HapticFeedback.notificationOccurred('error');
+                 for (let i = 0; i < files.length; i++) {
+                      const div = document.createElement('div');
+                      div.textContent = `❌ ${files[i].name}`; // Indicate error visually
+                      fileListPreview.appendChild(div);
+                  }
             } else {
-                 let previewHTML = `Selected ${files.length} file(s):<div>`;
+                uploadButtonText.textContent = `Загрузить ${files.length} файл(а)`;
+                uploadButton.disabled = false;
+                showStatus(''); // Clear status
                  for (let i = 0; i < files.length; i++) {
-                     previewHTML += `<div>${files[i].name} (${(files[i].size / 1024 / 1024).toFixed(2)} MB)</div>`;
-                 }
-                 previewHTML += '</div>';
-                 fileListPreview.innerHTML = previewHTML;
-                 uploadButton.disabled = false;
+                      const div = document.createElement('div');
+                      div.textContent = `• ${files[i].name}`;
+                      fileListPreview.appendChild(div);
+                  }
             }
-         }
-
+        }
 
-        async function handleUpload() {
-            const files = fileInput.files;
-            if (files.length === 0 || files.length > 20 || !currentInitData) {
-                showStatus('Invalid selection or missing user data.', 'error', 3000);
+        async function handleUpload(event) {
+            event.preventDefault();
+            if (isUploading || fileInput.files.length === 0 || fileInput.files.length > MAX_FILES) {
                 return;
             }
 
+            isUploading = true;
+            clearError();
             uploadButton.disabled = true;
-            showStatus('Uploading...', 'loading');
-            tg.MainButton.showProgress();
-            tg.MainButton.setParams({ text: "UPLOADING...", is_active: false });
-
+            uploadLoader.style.display = 'inline-block';
+            uploadButtonText.textContent = 'Загрузка...';
+            showStatus('Подготовка к загрузке...', 'info');
 
             const formData = new FormData();
-            for (let i = 0; i < files.length; i++) {
-                formData.append('files', files[i]);
+            formData.append('initData', tg.initData); // Send initData securely with the upload
+
+            for (let i = 0; i < fileInput.files.length; i++) {
+                formData.append('files', fileInput.files[i]);
             }
-            // Send initData in header for verification
-            // formData.append('initData', currentInitData); // Avoid sending in body if using header
 
             try {
-                const response = await fetch('/upload', {
-                    method: 'POST',
-                    headers: {
-                        'X-Telegram-Init-Data': currentInitData // Send initData securely in header
-                    },
-                    body: formData,
-                });
+                showStatus(`Загрузка ${fileInput.files.length} файл(ов)...`, 'info');
+                 const response = await fetch('/upload', {
+                     method: 'POST',
+                     body: formData,
+                     // Content-Type is automatically set by browser for FormData
+                 });
 
                 const data = await response.json();
 
                 if (response.ok && data.status === 'ok') {
-                    showStatus(`Successfully uploaded ${data.uploaded_count} file(s)!`, 'success', 3000);
-                    fileInput.value = ''; // Clear the input
-                    handleFileSelection(); // Update preview and button state
-                    await fetchFiles(); // Refresh the file list
-                    tg.HapticFeedback.notificationOccurred('success');
+                    showStatus(data.message || 'Файлы успешно загружены!', 'success');
+                    if (tg.HapticFeedback) tg.HapticFeedback.notificationOccurred('success');
+                    fileInput.value = ''; // Reset file input
+                    handleFileSelection(); // Update button state and preview
+                    await loadFiles(); // Refresh the file list
                 } else {
-                    throw new Error(data.message || `Upload failed (${response.status})`);
+                    throw new Error(data.message || `Ошибка загрузки: ${response.status}`);
                 }
             } catch (error) {
                 console.error('Upload error:', error);
-                showStatus(`Upload Error: ${error.message}`, 'error', 5000);
-                tg.HapticFeedback.notificationOccurred('error');
+                showStatus(`Ошибка: ${error.message}`, 'error');
+                showError(`Не удалось загрузить файлы: ${error.message}`);
+                 if (tg.HapticFeedback) tg.HapticFeedback.notificationOccurred('error');
             } finally {
-                uploadButton.disabled = false; // Re-enable after success/error, unless no files selected
-                handleFileSelection(); // Ensure button state is correct based on selection
-                tg.MainButton.hideProgress();
-                tg.MainButton.setParams({ text: "UPLOAD COMPLETE", is_active: true }); // Or revert to original text
-                // Maybe hide main button after completion? tg.MainButton.hide();
-                setTimeout(() => tg.MainButton.setParams({text: "UPLOAD", is_active: true }), 2000); // Revert button text
+                isUploading = false;
+                uploadLoader.style.display = 'none';
+                // Restore button text based on current file selection (might be empty now)
+                handleFileSelection();
+                 // Re-enable button only if files are selected and valid count
+                 uploadButton.disabled = (fileInput.files.length === 0 || fileInput.files.length > MAX_FILES);
             }
         }
 
-        function setupTelegram() {
+
+         function setupTelegram() {
              if (!tg || !tg.initData) {
-                 console.error("Telegram WebApp script not loaded or initData is missing.");
-                 document.body.innerHTML = '<p style="color: red; text-align: center; padding-top: 50px;">Error: Could not initialize Telegram Mini App interface. Please try reopening.</p>';
-                 document.body.style.visibility = 'visible';
+                 console.error("Telegram WebApp script не загружен или initData отсутствует.");
+                 greetingElement.textContent = 'Не удалось связаться с Telegram.';
+                 document.body.style.visibility = 'visible'; // Show body even if TG fails
+                 showError('Не удалось инициализировать приложение Telegram.');
                  return;
              }
 
-            tg.ready();
-            tg.expand();
-
-            applyTheme(tg.themeParams);
-            tg.onEvent('themeChanged', () => applyTheme(tg.themeParams));
-
-            currentInitData = tg.initData;
-
-            // Send initData for initial verification (optional, can rely on upload/list requests)
-            fetch('/verify', {
-                 method: 'POST',
-                 headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' },
-                 body: JSON.stringify({ initData: currentInitData }),
-             })
-             .then(response => response.json())
-             .then(data => {
-                 if (data.status === 'ok' && data.verified && data.user_id) {
-                     currentUserId = data.user_id;
-                     console.log('Initial verification successful. User ID:', currentUserId);
-                     fetchFiles(); // Fetch files now that we potentially have the user ID context
-                 } else {
-                     console.warn('Initial verification failed or user ID missing:', data.message);
-                     // Handle case where initial verify fails - maybe show error?
-                      myFilesList.innerHTML = `<li class="no-files">Error: Could not verify your Telegram account. ${data.message || ''}</li>`;
-                 }
-             })
-             .catch(error => {
-                 console.error('Error during initial verification:', error);
-                  myFilesList.innerHTML = `<li class="no-files">Error verifying account: ${error.message}</li>`;
-             });
-
-
-            fileInput.addEventListener('change', handleFileSelection);
-            uploadButton.addEventListener('click', handleUpload);
-
-            // Configure Main Button (Optional)
-            // tg.MainButton.setText("Upload Selected");
-            // tg.MainButton.onClick(handleUpload); // Trigger upload via main button
-            // fileInput.addEventListener('change', () => {
-            //     if (fileInput.files.length > 0 && fileInput.files.length <= 20) {
-            //         tg.MainButton.show().enable();
-            //     } else {
-            //         tg.MainButton.hide(); // Or disable: tg.MainButton.disable();
-            //     }
-            // });
-
-
-            document.body.style.visibility = 'visible';
+            try {
+                tg.ready();
+                tg.expand();
+
+                applyTheme(tg.themeParams);
+                tg.onEvent('themeChanged', () => applyTheme(tg.themeParams));
+
+                 // Initial verification call (optional, as actions verify anyway)
+                 fetch('/verify', {
+                     method: 'POST',
+                     headers: { 'Content-Type': 'application/json' },
+                     body: JSON.stringify({ initData: tg.initData }),
+                 }).then(response => response.json())
+                   .then(data => {
+                       if (data.status === 'ok' && data.verified) {
+                           console.log('Initial verification successful.');
+                            const user = data.user || tg.initDataUnsafe?.user;
+                            if (user) {
+                                const name = user.first_name || user.username || 'Пользователь';
+                                greetingElement.textContent = `Привет, ${name}! 👋`;
+                            } else {
+                                 greetingElement.textContent = 'Добро пожаловать!';
+                            }
+                            // Load files only after successful verification potentially
+                            loadFiles();
+                       } else {
+                           console.warn('Initial verification failed:', data.message);
+                           greetingElement.textContent = 'Добро пожаловать!';
+                           showError(`Ошибка авторизации: ${data.message || 'Неверные данные'}. Обновите приложение.`);
+                           // Don't load files if initial verify fails strictly
+                       }
+                   }).catch(error => {
+                        console.error('Initial verification request failed:', error);
+                        greetingElement.textContent = 'Ошибка соединения.';
+                        showError('Не удалось проверить авторизацию. Проверьте интернет-соединение.');
+                   });
+
+
+                fileInput.addEventListener('change', handleFileSelection);
+                uploadForm.addEventListener('submit', handleUpload);
+
+                 document.body.style.visibility = 'visible';
+
+            } catch (error) {
+                 console.error("Error during Telegram setup:", error);
+                 greetingElement.textContent = 'Ошибка инициализации.';
+                 showError(`Критическая ошибка: ${error.message}`);
+                 document.body.style.visibility = 'visible';
+            }
          }
 
+
+         // Attempt immediate setup, fallback to onload
         if (window.Telegram && window.Telegram.WebApp) {
             setupTelegram();
         } else {
             console.warn("Telegram WebApp script not immediately available, waiting for window.onload");
             window.addEventListener('load', setupTelegram);
-             // Fallback if load event doesn't fire or script fails
-             setTimeout(() => {
+            setTimeout(() => {
                  if (document.body.style.visibility !== 'visible') {
                       console.error("Telegram WebApp script fallback timeout triggered.");
-                      document.body.innerHTML = '<p style="color: red; text-align: center; padding-top: 50px;">Error: Failed to load Telegram interface components.</p>';
+                      greetingElement.textContent = 'Ошибка загрузки интерфейса Telegram.';
+                      showError('Не удалось загрузить интерфейс Telegram. Попробуйте перезапустить.');
                       document.body.style.visibility = 'visible';
                   }
              }, 3500);
@@ -594,155 +653,134 @@ TEMPLATE = """
 # --- Flask Routes ---
 @app.route('/')
 def index():
-    theme_params_json = request.args.get('themeParams', '{}')
-    try:
-        theme_params = json.loads(theme_params_json)
-    except json.JSONDecodeError:
-        theme_params = {}
-    color_scheme = request.args.get('colorScheme', 'light')
-    return render_template_string(TEMPLATE, theme=theme_params, color_scheme=color_scheme)
+    theme_params = {} # Let JS handle theme application
+    return render_template_string(TEMPLATE, theme=theme_params, max_files=MAX_FILES_PER_UPLOAD)
 
 @app.route('/verify', methods=['POST'])
 def verify_route():
-    try:
-        req_data = request.get_json()
-        init_data_str = req_data.get('initData')
-        if not init_data_str:
-            return jsonify({"status": "error", "verified": False, "message": "Missing initData"}), 400
+    req_data = request.get_json()
+    init_data_str = req_data.get('initData')
+    if not init_data_str:
+        return jsonify({"status": "error", "verified": False, "message": "Missing initData"}), 400
 
-        user_id = get_user_id_from_initdata(init_data_str)
+    user_data_parsed, is_valid, message = verify_telegram_data(init_data_str)
 
-        if user_id:
-            return jsonify({"status": "ok", "verified": True, "user_id": user_id}), 200
-        else:
-            logging.warning(f"Verification failed for initData: {init_data_str[:50]}...")
-            return jsonify({"status": "error", "verified": False, "message": "Invalid or unverifiable data"}), 403
+    user_info_dict = {}
+    if user_data_parsed and 'user' in user_data_parsed:
+        try:
+            user_json_str = unquote(user_data_parsed['user'][0])
+            user_info_dict = json.loads(user_json_str)
+        except Exception as e:
+            logging.error(f"Could not parse user JSON in /verify: {e}")
+
+    if is_valid:
+        return jsonify({"status": "ok", "verified": True, "user": user_info_dict}), 200
+    else:
+        return jsonify({"status": "error", "verified": False, "message": message, "user": user_info_dict}), 403
 
-    except Exception as e:
-        logging.exception("Error in /verify endpoint")
-        return jsonify({"status": "error", "verified": False, "message": "Internal server error"}), 500
 
 @app.route('/upload', methods=['POST'])
 def upload_files():
-    if not hf_api or not HF_TOKEN_WRITE:
-        return jsonify({"status": "error", "message": "Server configuration error: Hugging Face write access not available."}), 503
+    if not HF_TOKEN_WRITE:
+        return jsonify({"status": "error", "message": "Функция загрузки недоступна (ошибка конфигурации сервера)."}), 503
 
-    init_data_str = request.headers.get('X-Telegram-Init-Data')
+    init_data_str = request.form.get('initData')
     if not init_data_str:
-        return jsonify({"status": "error", "message": "Authentication required (Missing InitData Header)."}), 401
+        return jsonify({"status": "error", "message": "Ошибка авторизации: initData отсутствует."}), 400
 
-    user_id = get_user_id_from_initdata(init_data_str)
+    user_id = get_user_id_from_init_data(init_data_str)
     if not user_id:
-        return jsonify({"status": "error", "message": "Authentication failed (Invalid InitData)."}), 403
+        _, _, verification_message = verify_telegram_data(init_data_str) # Get specific reason
+        return jsonify({"status": "error", "message": f"Ошибка авторизации: {verification_message}"}), 403
 
     files = request.files.getlist('files')
     if not files:
-        return jsonify({"status": "error", "message": "No files provided in the request."}), 400
-    if len(files) > 20:
-         return jsonify({"status": "error", "message": "Too many files. Maximum is 20."}), 400
+        return jsonify({"status": "error", "message": "Файлы для загрузки не найдены."}), 400
 
-    uploaded_count = 0
+    if len(files) > MAX_FILES_PER_UPLOAD:
+         return jsonify({"status": "error", "message": f"Слишком много файлов. Максимум {MAX_FILES_PER_UPLOAD} за раз."}), 400
+
+    successful_uploads = 0
     errors = []
-    user_folder_path = f"{HF_UPLOAD_FOLDER}/{user_id}"
+    user_folder = f"{HF_UPLOAD_FOLDER}/{user_id}"
 
     for file in files:
         if file and file.filename:
             filename = secure_filename(file.filename)
-            path_in_repo = f"{user_folder_path}/{filename}"
-            logging.info(f"Attempting to upload '{filename}' for user {user_id} to {REPO_ID}/{path_in_repo}")
-
+            path_in_repo = f"{user_folder}/{filename}"
             try:
-                # Read file content into memory for upload
-                file_content = file.read()
-                file_like_object = io.BytesIO(file_content)
-
+                logging.info(f"Attempting to upload '{filename}' for user {user_id} to {REPO_ID}/{path_in_repo}")
+                # Pass file object directly
                 hf_api.upload_file(
-                    path_or_fileobj=file_like_object,
+                    path_or_fileobj=file.stream, # Use file.stream
                     path_in_repo=path_in_repo,
                     repo_id=REPO_ID,
                     repo_type="dataset",
+                    token=HF_TOKEN_WRITE,
                     commit_message=f"Upload {filename} by user {user_id}"
-                    # token=HF_TOKEN_WRITE is implicitly used by hf_api instance
                 )
-                uploaded_count += 1
-                logging.info(f"Successfully uploaded '{filename}' for user {user_id}.")
+                successful_uploads += 1
+                logging.info(f"Successfully uploaded '{filename}' for user {user_id}")
+            except HfHubHTTPError as e:
+                 logging.error(f"HTTP error uploading {filename} for user {user_id}: {e}")
+                 # Check for specific errors like 413 Payload Too Large if needed
+                 errors.append(f"{filename}: Ошибка сервера ({e.response.status_code if e.response else 'N/A'})")
             except Exception as e:
-                error_msg = f"Failed to upload {filename}: {str(e)}"
-                logging.error(error_msg, exc_info=True)
-                errors.append(error_msg)
+                logging.exception(f"Error uploading {filename} for user {user_id}")
+                errors.append(f"{filename}: {e}")
         else:
-             errors.append("Received an empty file part.")
-
+            errors.append("Получен пустой файл")
 
-    if errors:
-        if uploaded_count > 0:
-            return jsonify({
-                "status": "partial_error",
-                "message": f"Uploaded {uploaded_count} file(s) with errors on others.",
-                "errors": errors,
-                "uploaded_count": uploaded_count
-            }), 207 # Multi-Status
-        else:
-            return jsonify({
-                "status": "error",
-                "message": "Failed to upload any files.",
-                "errors": errors,
-                "uploaded_count": 0
-            }), 500
+    if successful_uploads > 0 and not errors:
+        return jsonify({"status": "ok", "message": f"Загружено {successful_uploads} файл(ов)."}), 200
+    elif successful_uploads > 0 and errors:
+        error_details = "; ".join(errors)
+        return jsonify({"status": "partial", "message": f"Загружено {successful_uploads} файл(ов). Ошибки: {error_details}"}), 207 # Multi-Status
     else:
-        return jsonify({"status": "ok", "message": f"Successfully uploaded {uploaded_count} files.", "uploaded_count": uploaded_count}), 200
+        error_details = "; ".join(errors)
+        return jsonify({"status": "error", "message": f"Не удалось загрузить файлы. Ошибки: {error_details}"}), 500
 
 
-@app.route('/list_files', methods=['GET'])
+@app.route('/list_files', methods=['POST'])
 def list_user_files():
-    if not hf_api:
-         return jsonify({"status": "error", "message": "Server configuration error: Hugging Face access not available."}), 503
+    if not HF_TOKEN_READ:
+         return jsonify({"status": "error", "message": "Функция просмотра файлов недоступна (ошибка конфигурации сервера)."}), 503
 
-    init_data_str = request.headers.get('X-Telegram-Init-Data')
+    req_data = request.get_json()
+    init_data_str = req_data.get('initData')
     if not init_data_str:
-        return jsonify({"status": "error", "message": "Authentication required (Missing InitData Header)."}), 401
+        return jsonify({"status": "error", "message": "Ошибка авторизации: initData отсутствует."}), 400
 
-    user_id = get_user_id_from_initdata(init_data_str)
+    user_id = get_user_id_from_init_data(init_data_str)
     if not user_id:
-        return jsonify({"status": "error", "message": "Authentication failed (Invalid InitData)."}), 403
+        _, _, verification_message = verify_telegram_data(init_data_str)
+        return jsonify({"status": "error", "message": f"Ошибка авторизации: {verification_message}"}), 403
 
-    user_folder_path = f"{HF_UPLOAD_FOLDER}/{user_id}"
-    logging.info(f"Listing files for user {user_id} in path: {user_folder_path}")
+    user_folder = f"{HF_UPLOAD_FOLDER}/{user_id}"
+    files_list = []
 
     try:
-        # Use list_repo_files which is efficient for listing
-        repo_files = list_repo_files(
-            repo_id=REPO_ID,
-            repo_type="dataset",
-            token=HF_TOKEN_READ or HF_TOKEN_WRITE, # Use read or write token
-            paths=[user_folder_path] # Specify the directory to list
-        )
-
-        # Filter out potential directory markers if any, though list_repo_files usually doesn't return them for subdirs
-        user_files_info = []
-        base_url = f"https://huggingface.co/datasets/{REPO_ID}/resolve/main"
+        repo_files = list_repo_files(repo_id=REPO_ID, repo_type="dataset", token=HF_TOKEN_READ, path_in_repo=user_folder)
 
         for file_path in repo_files:
-             # Ensure we only list files directly under the user's folder
-             if file_path.startswith(user_folder_path + "/") and file_path != user_folder_path + "/":
-                file_info = {
-                    "name": file_path, # Full path from repo root
-                    "url": f"{base_url}/{file_path}"
-                }
-                user_files_info.append(file_info)
+            # Ensure we only list files directly in the user's folder, not subfolders if any were created manually
+            if file_path.startswith(user_folder + "/") and file_path.count('/') == user_folder.count('/') + 1:
+                 filename = os.path.basename(file_path)
+                 file_url = f"https://huggingface.co/datasets/{REPO_ID}/resolve/main/{quote(file_path)}"
+                 files_list.append({
+                     "name": filename,
+                     "url": file_url,
+                     "path": file_path # Keep internal path if needed later
+                 })
+        return jsonify({"status": "ok", "files": files_list})
 
-        logging.info(f"Found {len(user_files_info)} file(s) for user {user_id}.")
-        return jsonify({"status": "ok", "files": user_files_info})
-
-    except EntryNotFoundError:
-         logging.info(f"No files found or directory does not exist for user {user_id} at path {user_folder_path}.")
-         return jsonify({"status": "ok", "files": []}) # Return empty list if user folder doesn't exist yet
     except RepositoryNotFoundError:
-         logging.error(f"Repository '{REPO_ID}' not found.")
-         return jsonify({"status": "error", "message": "Server configuration error: Target repository not found."}), 500
+         logging.warning(f"Repository {REPO_ID} or user folder {user_folder} not found.")
+         # This is expected if the user hasn't uploaded anything yet, return empty list
+         return jsonify({"status": "ok", "files": []})
     except Exception as e:
-        logging.error(f"Error listing files for user {user_id}: {e}", exc_info=True)
-        return jsonify({"status": "error", "message": "Internal server error while listing files."}), 500
+        logging.exception(f"Error listing files for user {user_id}")
+        return jsonify({"status": "error", "message": f"Не удалось получить список файлов: {e}"}), 500
 
 
 # --- App Initialization ---
@@ -752,30 +790,18 @@ if __name__ == '__main__':
     print("---")
     print(f"Flask server starting on http://{HOST}:{PORT}")
     print(f"Using Bot Token ID: {BOT_TOKEN.split(':')[0]}")
-    print(f"Target Hugging Face Repo: {REPO_ID}")
-    print(f"Upload Base Folder: {HF_UPLOAD_FOLDER}")
-    if not HF_TOKEN_WRITE and not HF_TOKEN_READ:
-         print("---")
-         print("--- CRITICAL WARNING: NO HUGGING FACE TOKEN SET ---")
-         print("--- File operations WILL FAIL. Set HF_TOKEN_WRITE or HF_TOKEN_READ environment variables.")
+    print(f"Hugging Face Repo: {REPO_ID}")
+    print(f"HF Upload Folder: {HF_UPLOAD_FOLDER}")
+    if not HF_TOKEN_READ or not HF_TOKEN_WRITE:
          print("---")
-    elif not HF_TOKEN_WRITE:
-         print("---")
-         print("--- WARNING: HF_TOKEN_WRITE NOT SET ---")
-         print("--- File uploads will be disabled. Read-only mode.")
+         print("--- WARNING: HUGGING FACE TOKEN(S) NOT SET ---")
+         print("--- File upload/listing WILL NOT WORK. Set HF_TOKEN_READ and HF_TOKEN_WRITE environment variables.")
          print("---")
     else:
-         print("--- Hugging Face Write Token found. Uploads enabled.")
-
-    if not app.secret_key or app.secret_key == b'default_secret':
-        print("---")
-        print("--- WARNING: Using default or insecure FLASK_SECRET_KEY ---")
-        print("--- Set a strong FLASK_SECRET_KEY environment variable for production.")
-        print("---")
+         print("--- Hugging Face tokens found.")
 
     print("--- Server Ready ---")
-    # For production, use a proper WSGI server like Gunicorn or Waitress
-    # Example using waitress:
+    # Use a production server like Waitress or Gunicorn instead of app.run() for deployment
     # from waitress import serve
     # serve(app, host=HOST, port=PORT)
-    app.run(host=HOST, port=PORT, debug=False) # debug=False is crucial for production
+    app.run(host=HOST, port=PORT, debug=False)