Update app.py

app.py

@@ -1,531 +1,558 @@
 import os
 import uuid
-import subprocess
-import time
-import socket
+from flask import Flask, request, jsonify, Response, send_from_directory, render_template_string, redirect, url_for, flash
+import google.generativeai as genai
+import json
 import logging
-import atexit
+import threading
+import time
 from datetime import datetime
-from flask import Flask, request, jsonify, Response, send_from_directory, redirect, url_for
-import google.generativeai as genai
-from huggingface_hub import HfApi, hf_hub_download
+from huggingface_hub import HfApi, hf_hub_download, delete_files
 from huggingface_hub.utils import RepositoryNotFoundError, HfHubHTTPError
-import requests # Нужен для HfHubHTTPError
+from werkzeug.utils import secure_filename
+from dotenv import load_dotenv
+import subprocess
+import sys
+import atexit
+
+load_dotenv()
 
-# --- Конфигурация ---
 app = Flask(__name__)
+app.secret_key = os.getenv("FLASK_SECRET_KEY", "super_secret_key_for_eva_generator")
 
-# ВНИМАНИЕ: Жестко закодированный API ключ - это небезопасно. Используйте переменные окружения.
-API_KEY_INTERNAL = "AIzaSyArKidc4o0MwbaCFKStlb2q2AwNg6Pnqns" # Используется ключ из Кода 1
-SITES_CACHE_DIR = 'generated_sites_cache' # Локальный кэш для .py файлов сайтов
+# --- Configuration from Code 1 (EVA - AI Site Generator) ---
+API_KEY_INTERNAL = os.getenv("GOOGLE_API_KEY", "AIzaSyArKidc4o0MwbaCFKStlb2q2AwNg6Pnqns") # Replace with your actual key or use env
+GENERATED_APPS_DIR = 'generated_python_apps'
 
-# Конфигурация Hugging Face (адаптировано из Кода 2)
-REPO_ID = "Kgshop/testsynk" # Указанный репозиторий
-HF_TOKEN_WRITE = os.getenv("HF_TOKEN") # Токен с правом записи
-HF_TOKEN_READ = os.getenv("HF_TOKEN_READ", HF_TOKEN_WRITE) # Токен для чтения (или тот же, что и для записи)
+# --- Configuration from Code 2 (Meka Shop - Backup/Sync) ---
+REPO_ID = "Kgshop/testsynk"
+HF_TOKEN_WRITE = os.getenv("HF_TOKEN_WRITE")
+HF_TOKEN_READ = os.getenv("HF_TOKEN_READ") # Can be same as write token
+
+APPS_MANIFEST_FILENAME = "apps_manifest.json"
+HF_APPS_DIR_IN_REPO = "apps" # Directory in Hugging Face repo for .py files
 
 DOWNLOAD_RETRIES = 3
 DOWNLOAD_DELAY = 5
+BACKUP_INTERVAL_SECONDS = 1800 # 30 minutes
 
-# Управление запущенными сайтами
-RUNNING_SITES = {} # {'site_filename.py': {'process': Popen_object, 'port': 5001, 'host': '127.0.0.1'}}
-BASE_PORT_FOR_GENERATED_SITES = 8001
-USED_PORTS = set()
-
-# --- Настройка Логирования ---
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
-# --- Создание директорий ---
-if not os.path.exists(SITES_CACHE_DIR):
-    os.makedirs(SITES_CACHE_DIR)
+if not os.path.exists(GENERATED_APPS_DIR):
+    os.makedirs(GENERATED_APPS_DIR)
 
-# --- Функции для работы с Hugging Face ---
-def download_file_from_hf(repo_filename, local_save_path, retries=DOWNLOAD_RETRIES, delay=DOWNLOAD_DELAY):
-    if not HF_TOKEN_READ:
-        logging.warning("HF_TOKEN_READ not set. Download might fail for private repos.")
-    
-    token_to_use = HF_TOKEN_READ
+# In-memory store for running app subprocesses
+# Key: app_id, Value: {"process": Popen_object, "port": port, "filename": filename, "status": "running"}
+running_apps_processes = {}
+# Port assignment
+next_available_port = int(os.getenv("START_PORT_GENERATED_APPS", 7861))
 
-    logging.info(f"Attempting download for {repo_filename} from {REPO_ID} to {local_save_path}...")
-    for attempt in range(retries + 1):
-        try:
-            logging.info(f"Downloading {repo_filename} (Attempt {attempt + 1}/{retries + 1})...")
-            downloaded_path = hf_hub_download(
-                repo_id=REPO_ID,
-                filename=repo_filename,
-                repo_type="dataset", # Обычно 'dataset' для файлов, или 'model'
-                token=token_to_use,
-                local_dir=os.path.dirname(local_save_path),
-                local_dir_use_symlinks=False,
-                force_download=True, # Всегда скачивать свежую версию
-                resume_download=False,
-                # Важно указать имя файла, если local_dir указан, иначе он создаст структуру папок репозитория
-                # hf_hub_download вернет полный путь к файлу, который может включать структуру папок репозитория.
-                # Мы должны убедиться, что он сохраняется как local_save_path
-            )
-            # Переименовываем/перемещаем, если hf_hub_download скачал не точно по пути
-            if downloaded_path != local_save_path:
-                os.makedirs(os.path.dirname(local_save_path), exist_ok=True)
-                os.replace(downloaded_path, local_save_path) # Используем replace для атомарности
-                logging.info(f"File moved from {downloaded_path} to {local_save_path}")
+# --- Hugging Face Sync Logic (Adapted from Code 2) ---
 
-            logging.info(f"Successfully downloaded {repo_filename} to {local_save_path}.")
-            return True
-        except RepositoryNotFoundError:
-            logging.error(f"Repository {REPO_ID} not found. Download cancelled.")
-            return False
-        except HfHubHTTPError as e:
-            if e.response.status_code == 404:
-                logging.warning(f"File {repo_filename} not found in repo {REPO_ID} (404).")
-                return False # Файл не найден, нет смысла ретраить
-            logging.error(f"HTTP error downloading {repo_filename} (Attempt {attempt + 1}): {e}. Retrying in {delay}s...")
-        except requests.exceptions.RequestException as e: # requests используется внутри huggingface_hub
-            logging.error(f"Network error downloading {repo_filename} (Attempt {attempt + 1}): {e}. Retrying in {delay}s...")
-        except Exception as e:
-            logging.error(f"Unexpected error downloading {repo_filename} (Attempt {attempt + 1}): {e}. Retrying in {delay}s...", exc_info=True)
-        
-        if attempt < retries:
-            time.sleep(delay)
-    
-    logging.error(f"Failed to download {repo_filename} after {retries + 1} attempts.")
-    return False
+def _get_hf_token(write_access=False):
+    if write_access:
+        return HF_TOKEN_WRITE
+    return HF_TOKEN_READ if HF_TOKEN_READ else HF_TOKEN_WRITE
 
-def upload_file_to_hf(local_filepath, path_in_repo):
+def upload_to_hf(local_path, path_in_repo, commit_message=None):
     if not HF_TOKEN_WRITE:
-        logging.warning("HF_TOKEN_WRITE (for writing) not set. Skipping upload to Hugging Face.")
+        logging.warning(f"HF_TOKEN_WRITE not set. Skipping upload of {local_path} to HF.")
         return False
-    if not os.path.exists(local_filepath):
-        logging.error(f"Local file {local_filepath} not found. Skipping upload.")
+    if not os.path.exists(local_path):
+        logging.warning(f"Local file {local_path} not found. Skipping upload.")
         return False
+
+    api = HfApi()
+    if not commit_message:
+        commit_message = f"Sync {os.path.basename(local_path)} {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
     try:
-        api = HfApi()
-        logging.info(f"Starting upload of {local_filepath} to {path_in_repo} in HF repo {REPO_ID}...")
+        logging.info(f"Uploading {local_path} to {REPO_ID}/{path_in_repo}...")
         api.upload_file(
-            path_or_fileobj=local_filepath,
+            path_or_fileobj=local_path,
             path_in_repo=path_in_repo,
             repo_id=REPO_ID,
             repo_type="dataset",
             token=HF_TOKEN_WRITE,
-            commit_message=f"Sync {path_in_repo} {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
+            commit_message=commit_message
         )
-        logging.info(f"File {local_filepath} successfully uploaded to {path_in_repo} in Hugging Face.")
+        logging.info(f"Successfully uploaded {local_path} to HF.")
         return True
     except Exception as e:
-        logging.error(f"Error uploading file {local_filepath} to Hugging Face: {e}", exc_info=True)
+        logging.error(f"Error uploading {local_path} to Hugging Face: {e}")
         return False
 
-# --- Функции управления дочерними сайтами ---
-def find_free_port(start_port):
-    port = start_port
-    while True:
-        if port in USED_PORTS:
-            port += 1
-            continue
-        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-            try:
-                s.bind(('127.0.0.1', port))
-                USED_PORTS.add(port)
-                return port
-            except OSError:
-                logging.warning(f"Port {port} is already in use by another application, trying next.")
-                # Добавляем в USED_PORTS, чтобы не пробовать его снова в этой сессии для наших сайтов
-                USED_PORTS.add(port) 
-                port += 1
-        if port > 65535:
-            raise RuntimeError("Could not find a free port.")
-
-
-def start_generated_site(py_filename):
-    if py_filename in RUNNING_SITES:
-        site_info = RUNNING_SITES[py_filename]
-        # Проверить, жив ли процесс
-        if site_info['process'].poll() is None: # None значит, что процесс еще работает
-            logging.info(f"Site {py_filename} is already running on port {site_info['port']}.")
-            return site_info['host'], site_info['port']
-        else:
-            logging.warning(f"Site {py_filename} was marked as running but process died. Cleaning up.")
-            USED_PORTS.discard(site_info['port'])
-            del RUNNING_SITES[py_filename]
+def download_from_hf(filename_in_repo, local_dir=".", force_download=True, retries=DOWNLOAD_RETRIES, delay=DOWNLOAD_DELAY):
+    token_to_use = _get_hf_token()
+    if not token_to_use:
+         logging.warning(f"No HF token for reading. Download of {filename_in_repo} might fail for private repos.")
 
-    local_py_path = os.path.join(SITES_CACHE_DIR, py_filename)
-    
-    # 1. Скачать/убедиться в наличии файла
-    if not os.path.exists(local_py_path):
-        if not download_file_from_hf(f"sites/{py_filename}", local_py_path):
-            logging.error(f"Failed to download site {py_filename} from Hugging Face.")
-            return None, None
-    
-    # 2. Найти свободный порт и модифицировать код сайта
-    try:
-        assigned_port = find_free_port(BASE_PORT_FOR_GENERATED_SITES)
-        with open(local_py_path, 'r', encoding='utf-8') as f:
-            original_code = f.read()
-        
-        # Заменить плейсхолдер порта
-        modified_code = original_code.replace("{{GENERATED_APP_PORT}}", str(assigned_port))
-        
-        # Убедимся, что код пытается запуститься на 0.0.0.0 или 127.0.0.1
-        # Это очень грубая проверка, лучше если AI генерирует предсказуемый app.run
-        if f"app.run(host='0.0.0.0', port={assigned_port})" not in modified_code and \
-           f"app.run(host='127.0.0.1', port={assigned_port})" not in modified_code and \
-           f"app.run(port={assigned_port}, host='0.0.0.0')" not in modified_code and \
-           f"app.run(port={assigned_port}, host='127.0.0.1')" not in modified_code:
-            
-            # Попробуем заменить более общий app.run(port=XXXX) или app.run()
-            import re
-            modified_code = re.sub(
-                r"app\.run\((.*)\)", 
-                f"app.run(host='0.0.0.0', port={assigned_port})", 
-                modified_code, 
-                flags=re.DOTALL
-            )
-            if "app.run(" not in modified_code : # Если app.run не было вообще
-                 modified_code += f"\n\nif __name__ == '__main__':\n    app.run(host='0.0.0.0', port={assigned_port})\n"
+    success = False
+    local_path_to_save = os.path.join(local_dir, os.path.basename(filename_in_repo))
 
+    for attempt in range(retries + 1):
+        try:
+            logging.info(f"Downloading {filename_in_repo} from {REPO_ID} (Attempt {attempt + 1})...")
+            # Ensure local directory for the file exists
+            os.makedirs(os.path.dirname(local_path_to_save), exist_ok=True)
 
-        with open(local_py_path, 'w', encoding='utf-8') as f:
-            f.write(modified_code)
+            downloaded_path = hf_hub_download(
+                repo_id=REPO_ID,
+                filename=filename_in_repo,
+                repo_type="dataset",
+                token=token_to_use,
+                local_dir=local_dir, # hf_hub_download will place it correctly based on filename_in_repo structure if local_dir is base
+                local_dir_use_symlinks=False,
+                force_download=force_download,
+                resume_download=False
+            )
+            # hf_hub_download returns the full path, ensure it's where we expect or move it
+            # For simple case, if filename_in_repo is just a name, it's downloaded to local_dir/filename_in_repo
+            # If filename_in_repo includes slashes, it respects that structure inside local_dir
+            # So, downloaded_path should be local_path_to_save if filename_in_repo doesn't have internal dirs
+            # Let's verify by checking if the expected file exists after download
+            # The path hf_hub_download actually uses:
+            actual_downloaded_file = os.path.join(local_dir, filename_in_repo)
+            if os.path.exists(actual_downloaded_file):
+                 logging.info(f"Successfully downloaded {filename_in_repo} to {actual_downloaded_file}.")
+                 success = True
+                 return actual_downloaded_file # Return the actual path
+            else:
+                 logging.error(f"File {filename_in_repo} reported as downloaded by hf_hub, but not found at {actual_downloaded_file}.")
+                 # This case might happen if filename_in_repo had path segments. hf_hub_download creates them.
+
+            success = True # if no error from hf_hub_download
+            break
+        except HfHubHTTPError as e:
+            if e.response.status_code == 404:
+                logging.warning(f"File {filename_in_repo} not found in repo {REPO_ID} (404).")
+                return None # File not found is a definitive result
+            logging.error(f"HTTP error downloading {filename_in_repo} (Attempt {attempt + 1}): {e}")
+        except Exception as e:
+            logging.error(f"Unexpected error downloading {filename_in_repo} (Attempt {attempt + 1}): {e}")
 
-    except Exception as e:
-        logging.error(f"Error preparing site {py_filename} for launch: {e}", exc_info=True)
-        if 'assigned_port' in locals() and assigned_port:
-            USED_PORTS.discard(assigned_port)
-        return None, None
+        if attempt < retries:
+            time.sleep(delay)
 
-    # 3. Запустить скрипт
-    try:
-        # Для Windows, если python не в PATH, может понадобиться sys.executable
-        # python_executable = sys.executable  
-        python_executable = "python" # Предполагаем, что python в PATH
-        process = subprocess.Popen(
-            [python_executable, local_py_path],
-            stdout=subprocess.PIPE, # Можно перенаправить в лог-файлы
-            stderr=subprocess.PIPE
-        )
-        time.sleep(2) # Дать время Flask-приложению запуститься
+    if success:
+        # The file is downloaded directly into the structure matching path_in_repo within local_dir
+        # So GENERATED_APPS_DIR/app_xyz.py or ./apps_manifest.json
+        final_path = os.path.join(local_dir, filename_in_repo)
+        if os.path.exists(final_path):
+            return final_path
+        else: # Fallback if pathing is tricky with hf_hub_download's behavior
+            base_filename = os.path.basename(filename_in_repo)
+            simple_final_path = os.path.join(local_dir, base_filename)
+            if os.path.exists(simple_final_path):
+                return simple_final_path
+            logging.error(f"Downloaded file {filename_in_repo} but cannot locate it finally.")
+            return None
+    else:
+        logging.error(f"Failed to download {filename_in_repo} after retries.")
+        return None
 
-        if process.poll() is not None: # Если процесс сразу завершился
-            stdout, stderr = process.communicate()
-            logging.error(f"Site {py_filename} failed to start. Return code: {process.returncode}")
-            logging.error(f"Stdout: {stdout.decode(errors='ignore')}")
-            logging.error(f"Stderr: {stderr.decode(errors='ignore')}")
-            USED_PORTS.discard(assigned_port)
-            return None, None
 
-        site_host = '127.0.0.1' # Сгенерированные сайты слушают на 0.0.0.0, но доступны через 127.0.0.1
-        RUNNING_SITES[py_filename] = {'process': process, 'port': assigned_port, 'host': site_host}
-        logging.info(f"Site {py_filename} started successfully on http://{site_host}:{assigned_port}")
-        return site_host, assigned_port
-    except Exception as e:
-        logging.error(f"Error launching site {py_filename}: {e}", exc_info=True)
-        if 'assigned_port' in locals() and assigned_port:
-            USED_PORTS.discard(assigned_port)
-        return None, None
-
-def cleanup_running_sites():
-    logging.info("Cleaning up running generated sites...")
-    for filename, site_info in list(RUNNING_SITES.items()): # list() для копии, т.к. будем удалять
+def load_apps_manifest():
+    manifest_path = os.path.join(".", APPS_MANIFEST_FILENAME) # Manifest is in root
+    if os.path.exists(manifest_path):
         try:
-            if site_info['process'].poll() is None: # Если процесс еще жив
-                logging.info(f"Terminating site {filename} (PID: {site_info['process'].pid}) on port {site_info['port']}")
-                site_info['process'].terminate() # Сначала пробуем мягко
-                try:
-                    site_info['process'].wait(timeout=5) # Ждем завершения
-                except subprocess.TimeoutExpired:
-                    logging.warning(f"Site {filename} did not terminate gracefully, killing.")
-                    site_info['process'].kill() # Если не помогло - жестко
-            USED_PORTS.discard(site_info['port'])
-            del RUNNING_SITES[filename]
-        except Exception as e:
-            logging.error(f"Error terminating site {filename}: {e}", exc_info=True)
-    logging.info("Cleanup complete.")
+            with open(manifest_path, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except json.JSONDecodeError:
+            logging.error(f"Error decoding {APPS_MANIFEST_FILENAME}. Returning empty manifest.")
+            return {}
+    return {}
+
+def save_apps_manifest(manifest_data):
+    manifest_path = os.path.join(".", APPS_MANIFEST_FILENAME)
+    try:
+        with open(manifest_path, 'w', encoding='utf-8') as f:
+            json.dump(manifest_data, f, indent=4, ensure_ascii=False)
+        logging.info(f"{APPS_MANIFEST_FILENAME} saved successfully.")
+        return True
+    except Exception as e:
+        logging.error(f"Error saving {APPS_MANIFEST_FILENAME}: {e}")
+        return False
+
+def sync_manifest_to_hf():
+    manifest_path = os.path.join(".", APPS_MANIFEST_FILENAME)
+    if os.path.exists(manifest_path):
+        upload_to_hf(manifest_path, APPS_MANIFEST_FILENAME, f"Update {APPS_MANIFEST_FILENAME}")
+    else:
+        logging.warning(f"{APPS_MANIFEST_FILENAME} not found locally to upload.")
 
-atexit.register(cleanup_running_sites)
 
+def sync_app_py_file_to_hf(app_id, manifest):
+    if app_id not in manifest:
+        logging.warning(f"App ID {app_id} not in manifest. Cannot sync .py file to HF.")
+        return False
+    app_entry = manifest[app_id]
+    local_py_path = os.path.join(GENERATED_APPS_DIR, app_entry['filename'])
+    hf_py_path = f"{HF_APPS_DIR_IN_REPO}/{app_entry['filename']}"
+    if os.path.exists(local_py_path):
+        return upload_to_hf(local_py_path, hf_py_path, f"Update app: {app_entry['filename']}")
+    return False
 
-# --- Функция генерации кода сайта с помощью Google AI ---
-def generate_full_python_site_from_prompt(user_prompt):
+def initial_sync_from_hf():
+    logging.info("Starting initial sync from Hugging Face...")
+    # 1. Download manifest
+    manifest_local_path = download_from_hf(APPS_MANIFEST_FILENAME, local_dir=".")
+    manifest = {}
+    if manifest_local_path and os.path.exists(manifest_local_path):
+        manifest = load_apps_manifest()
+        logging.info(f"{APPS_MANIFEST_FILENAME} loaded after download.")
+    else:
+        logging.warning(f"Could not download or load {APPS_MANIFEST_FILENAME}. Starting with empty/local manifest.")
+        manifest = load_apps_manifest() # Try local if download failed
+
+    # 2. Download app .py files mentioned in manifest
+    if manifest:
+        logging.info(f"Manifest loaded, checking {len(manifest)} app entries for download.")
+        for app_id, app_entry in manifest.items():
+            local_py_path = os.path.join(GENERATED_APPS_DIR, app_entry['filename'])
+            hf_py_path = f"{HF_APPS_DIR_IN_REPO}/{app_entry['filename']}"
+            if not os.path.exists(local_py_path): # Only download if not exists locally
+                logging.info(f"App file {app_entry['filename']} not found locally. Attempting download.")
+                downloaded_py_path = download_from_hf(hf_py_path, local_dir=GENERATED_APPS_DIR)
+                if downloaded_py_path:
+                    logging.info(f"App {app_entry['filename']} downloaded to {downloaded_py_path}.")
+                else:
+                    logging.warning(f"Failed to download app {app_entry['filename']} for app_id {app_id}.")
+            else:
+                logging.info(f"App file {app_entry['filename']} already exists locally. Skipping download.")
+    else:
+        logging.info("Manifest is empty or could not be loaded. No app .py files to download.")
+    logging.info("Initial sync from Hugging Face finished.")
+    return manifest
+
+
+def periodic_backup_job():
+    logging.info("Periodic backup: Starting...")
+    manifest = load_apps_manifest()
+    if not manifest and not os.path.exists(APPS_MANIFEST_FILENAME): # if manifest is empty and file doesnt exist, create one
+        save_apps_manifest({}) # Create an empty one if it doesn't exist at all
+
+    sync_manifest_to_hf() # Upload current manifest
+
+    # Optionally, upload all local .py files if they are not on HF or changed
+    # For simplicity in this version, we mainly rely on upload during generation
+    # A more robust sync would check hashes or modification times.
+    # For now, let's assume if an app is in manifest, its .py should be on HF
+    # if it was generated and uploaded successfully.
+    # This periodic backup mainly ensures the manifest is up-to-date on HF.
+    # If you want to ensure all local py files are on HF:
+    for app_id, app_entry in manifest.items():
+         local_py_path = os.path.join(GENERATED_APPS_DIR, app_entry['filename'])
+         if os.path.exists(local_py_path): # If it exists locally, ensure it's on HF
+             # This could be more intelligent (e.g., check if already uploaded or changed)
+             # For now, it might re-upload, which is acceptable for a backup
+             logging.info(f"Periodic backup: Checking app {app_entry['filename']} for HF sync.")
+             sync_app_py_file_to_hf(app_id, manifest)
+
+    logging.info("Periodic backup: Finished.")
+
+# --- AI Generation Logic (Adapted from Code 1) ---
+
+def generate_python_app_from_prompt(user_prompt):
+    global API_KEY_INTERNAL
     try:
-        # ВНИМАНИЕ: Ключ API жестко закодирован. В продакшене используйте переменные окружения.
         genai.configure(api_key=API_KEY_INTERNAL)
     except Exception as e:
-        logging.error(f"Error configuring GenAI: {e}", exc_info=True)
+        logging.error(f"Error configuring GenAI: {e}")
         raise ValueError(f"Не удалось настроить Google AI. Проблема с конфигурацией. Ошибка: {e}")
 
     if not user_prompt or not user_prompt.strip():
         raise ValueError("Текстовый запрос (промпт) не может быть пустым.")
 
     system_instruction = (
-        "You are an expert Python web developer. Your task is to generate a complete, single-file Flask application "
-        "based on the user's request. The entire application must be contained in a single .py file.\n"
-        "Follow these requirements strictly:\n"
-        "1.  **Flask Application:** The code must be a runnable Flask application.\n"
-        "2.  **Single File:** All code, including HTML templates, CSS, and JavaScript, must be in this single Python file.\n"
-        "3.  **HTML Templates:** Embed HTML as Python strings. Use `flask.render_template_string()`.\n"
-        "4.  **CSS/JS:** Inline CSS within `<style>` tags in the HTML strings. Inline JavaScript within `<script>` tags in the HTML strings. Do not use external files for CSS/JS.\n"
-        "5.  **Routes:** Define Flask routes as requested by the user.\n"
-        "6.  **`app.run`:** Crucially, the script MUST end with a block like this for запуска:\n"
-        "   ```python\n"
-        "   if __name__ == '__main__':\n"
-        "       # IMPORTANT: The port number MUST be the placeholder {{GENERATED_APP_PORT}}\n"
-        "       # The host should be '0.0.0.0' to be accessible.\n"
-        "       app.run(host='0.0.0.0', port={{GENERATED_APP_PORT}})\n"
-        "   ```\n"
-        "7.  **No External File Dependencies:** The script should not rely on any other local files (e.g., for images, data) unless explicitly creating and managing them (e.g. a simple data.json). Images should preferably be placeholder URLs (e.g., from placehold.co) or base64 encoded if small and necessary.\n"
-        "8.  **Self-Contained Database (Optional):** If the site requires data persistence, it should use a simple mechanism like storing data in Python dictionaries or lists within the script itself. For more complex needs, it could read/write to a single JSON file named `data.json` *in its current working directory if absolutely necessary*, and the script should handle its creation. Avoid complex databases or ORMs.\n"
-        "9.  **Direct Python Output:** Output ONLY the Python code. Do NOT include ```python, markdown, or any explanatory text before or after the code block. The output must start with `import flask` or similar Python code and end with the `app.run` block.\n"
-        "10. **Error Handling & Imports:** Include necessary imports (like `from flask import Flask, render_template_string, request, ...`). Add basic error handling if appropriate for the requested site.\n"
-        "11. **Character Encoding:** Ensure any HTML generated uses UTF-8.\n"
-        "12. **Simplicity:** Favor simplicity and clarity in the generated code."
+        "You are an expert Python Flask web developer. Your task is to generate a complete, single-file Flask application "
+        "based on the user's request. The Python file must be fully self-contained.\n"
+        "This means:\n"
+        "1. All HTML should be returned as strings within Flask route functions, or using `render_template_string`.\n"
+        "   For example: `return '<h1>Hello</h1>'` or `return render_template_string('<h1>{{name}}</h1>', name='World')`.\n"
+        "2. All CSS styles must be included within `<style>` tags inside the HTML strings.\n"
+        "3. All client-side JavaScript code must be included within `<script>` tags inside the HTML strings.\n"
+        "4. Do not use external CSS/JS files. Do not use `render_template` with separate template files.\n"
+        "5. If the app needs to store data, use in-memory Python dictionaries or lists. Avoid file I/O unless very simple and specified.\n"
+        "6. The generated Python code should be well-formed and ready to be saved as a .py file and run.\n"
+        "7. Ensure character encoding for HTML is UTF-8 (e.g., `<meta charset=\"UTF-8\">`).\n"
+        "8. The Flask app should be runnable on `0.0.0.0` and use a specific port placeholder `APP_PORT`.\n"
+        "   The `app.run` call MUST look like this: `app.run(host='0.0.0.0', port=APP_PORT)`\n"
+        "9. Make sure to include `from flask import Flask, render_template_string, request, jsonify` or other necessary imports.\n"
+        "10. The application should be defined as `app = Flask(__name__)`.\n"
+        "11. Directly output ONLY the Python code starting with import statements and ending with the `if __name__ == '__main__':` block. Do not include any explanatory text, markdown formatting (like ```python), or anything else before or after the Python code itself."
+        "12. The app should be functional and somewhat visually appealing given the constraints."
+        "Example of a minimal app structure:\n"
+        "```python\n"
+        "from flask import Flask, render_template_string\n\n"
+        "app = Flask(__name__)\n\n"
+        "@app.route('/')\n"
+        "def home():\n"
+        "    html_content = \"\"\"\n"
+        "    <!DOCTYPE html><html><head><meta charset='UTF-8'><title>My App</title></head>\n"
+        "    <body><h1>Welcome!</h1></body></html>\n"
+        "    \"\"\"\n"
+        "    return html_content\n\n"
+        "if __name__ == '__main__':\n"
+        "    APP_PORT = 5000 # This will be replaced by the generator\n"
+        "    app.run(host='0.0.0.0', port=APP_PORT)\n"
+        "```\n"
+        "Ensure the `APP_PORT` variable is defined before `app.run` if you are using it like `port=APP_PORT`, or directly use the placeholder `app.run(host='0.0.0.0', port=APP_PORT)` without defining it. The latter is preferred: `app.run(host='0.0.0.0', port=APP_PORT)`"
     )
-    
+
     full_prompt = f"{system_instruction}\n\nUser request: \"{user_prompt}\""
     
-    response_obj = None # Для отладки prompt_feedback
+    response_obj = None # To store the raw response object for debugging
     try:
-        # Рекомендуется использовать более новые модели для генерации кода, например, Gemini
-        model = genai.GenerativeModel('gemini-1.5-flash-latest') # Заменено с learnlm-2.0-flash-experimental
+        model = genai.GenerativeModel('gemini-1.0-pro-latest') # Using a more capable model for code
+        # model = genai.GenerativeModel('learnlm-2.0-flash-experimental') # As in original code 1
         response_obj = model.generate_content(full_prompt)
 
         generated_text = ""
-        # Обработка ответа согласно документации Gemini
+        # Handle different response structures
         if hasattr(response_obj, 'text') and response_obj.text:
             generated_text = response_obj.text
         elif hasattr(response_obj, 'parts') and response_obj.parts:
             generated_text = "".join(part.text for part in response_obj.parts if hasattr(part, 'text'))
         
         if not generated_text.strip():
-             # Проверка на блокировку контента
-             if hasattr(response_obj, 'prompt_feedback') and \
-                hasattr(response_obj.prompt_feedback, 'block_reason') and \
-                response_obj.prompt_feedback.block_reason:
-                 reason = response_obj.prompt_feedback.block_reason
-                 raise ValueError(f"Генерация контента заблокирована из-за политики безопасности (причина: {reason}). Попробуйте другой запрос.")
-             else:
-                raise ValueError("Модель вернула пустой результат. Попробуйте изменить запрос.")
+            # Check for blocking reasons if the response object has prompt_feedback
+            if hasattr(response_obj, 'prompt_feedback') and response_obj.prompt_feedback:
+                block_reason = getattr(response_obj.prompt_feedback, 'block_reason', None)
+                if block_reason:
+                    raise ValueError(f"Генерация контента заблокирована (причина: {block_reason}). Попробуйте другой запрос.")
+            raise ValueError("Модель вернула пустой результат. Попробуйте изменить запрос.")
         
-        # Очистка от markdown, если модель его добавила
+        # Clean markdown ```python ... ```
         clean_text = generated_text.strip()
         if clean_text.startswith("```python"):
-            clean_text = clean_text[9:] # Удаляем ```python
-            if clean_text.endswith("```"):
-                clean_text = clean_text[:-3] # Удаляем ```
-            generated_text = clean_text.strip()
-        elif clean_text.startswith("```"): # Общий случай для ``` без указания языка
-            clean_text = clean_text[3:]
+            clean_text = clean_text[9:] # len("```python\n")
             if clean_text.endswith("```"):
                 clean_text = clean_text[:-3]
-            generated_text = clean_text.strip()
+        elif clean_text.startswith("```"): # More generic markdown block
+             clean_text = clean_text[3:]
+             if clean_text.endswith("```"):
+                clean_text = clean_text[:-3]
 
-        if not (generated_text.startswith("import ") or generated_text.startswith("from ")):
-            logging.warning(f"Generated code might not be pure Python. Preview: {generated_text[:200]}")
-            # Дополнительная проверка не помешает, но AI должен следовать инструкциям
+        generated_text = clean_text.strip()
+
+        if not "Flask(__name__)" in generated_text or not "app.run" in generated_text:
+             logging.warning(f"Generated text might not be a valid Flask app. Preview: {generated_text[:300]}")
+             # raise ValueError("Сгенерированный код не похож на Flask приложение. Проверьте результат.") # Too strict for now
+
+        if "port=APP_PORT" not in generated_text and "port = APP_PORT" not in generated_text :
+            logging.warning("Generated app does not contain 'port=APP_PORT'. It might not be configurable by the generator.")
+            # Could attempt to inject it, but risky. For now, rely on AI.
 
         return generated_text
 
     except Exception as e:
-        logging.error(f"Error generating content with GenAI: {e}", exc_info=True)
+        logging.error(f"Error generating content with GenAI: {e}")
         error_message = str(e)
-        # Более детальная обработка ошибок API
+        # Add detailed error checks from original code 1 if needed
         if "API key not valid" in error_message:
-             raise ValueError("Внутренняя ошибка конфигурации API Google AI. Проверьте ключ.")
-        elif "Billing account not found" in error_message or "billing account" in error_message.lower():
-             raise ValueError("Проблема с биллингом аккаунта Google Cloud.")
-        elif "Could not find model" in error_message:
-             raise ValueError(f"Модель не найдена или недоступна. Убедитесь, что модель 'gemini-1.5-flash-latest' активна.")
-        elif "resource has been exhausted" in error_message.lower() or "quota" in error_message.lower():
-             raise ValueError("Квота запросов к Google AI исчерпана. Попробуйте позже.")
-        elif "content has been blocked" in error_message.lower() or \
-             (response_obj and hasattr(response_obj, 'prompt_feedback') and \
-              hasattr(response_obj.prompt_feedback, 'block_reason') and \
-              response_obj.prompt_feedback.block_reason):
-            reason = "неизвестна"
-            if response_obj and hasattr(response_obj, 'prompt_feedback') and hasattr(response_obj.prompt_feedback, 'block_reason') and response_obj.prompt_feedback.block_reason:
-                reason = response_obj.prompt_feedback.block_reason
-            elif "safety settings" in error_message.lower():
-                reason = "настройки безопасности"
-            raise ValueError(f"Генерация контента заблокирована (причина: {reason}). Попробуйте другой запрос.")
-        # Ошибка из raise ValueError выше
-        elif "Генерация контента заблокирована" in error_message or "Модель вернула пустой результат" in error_message:
-            raise # Перебрасываем уже обработанную ошибку
+             raise ValueError("Внутренняя ошибка конфигурации API Google.")
+        # ... (other specific error messages from original code)
         else:
-             raise ValueError(f"Неизвестная ошибка при генерации Python-кода сайта: {e}")
+             raise ValueError(f"Ошибка при генерации Python-кода приложения: {e}")
+
+
+# --- Process Management ---
+def get_next_app_port():
+    global next_available_port
+    # In a real app, you'd check if port is actually free
+    port_to_use = next_available_port
+    next_available_port += 1
+    return port_to_use
+
+def start_python_app(app_id, filepath, port):
+    global running_apps_processes
+    try:
+        # Read the generated code
+        with open(filepath, 'r', encoding='utf-8') as f:
+            code = f.read()
+        
+        # Replace the port placeholder
+        # Ensure APP_PORT is consistently used for replacement
+        code = code.replace("APP_PORT", str(port)) 
+        
+        # Overwrite the file with the new port
+        with open(filepath, 'w', encoding='utf-8') as f:
+            f.write(code)
+
+        # Start the Flask app as a subprocess
+        # Use sys.executable to ensure it's the same Python interpreter
+        process = subprocess.Popen([sys.executable, filepath], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        running_apps_processes[app_id] = {"process": process, "port": port, "filename": os.path.basename(filepath), "status": "starting"}
+        
+        # Give it a moment to start or fail
+        time.sleep(2) 
+        if process.poll() is None: # Still running
+            running_apps_processes[app_id]["status"] = "running"
+            logging.info(f"Python app {filepath} started on port {port} with PID {process.pid}.")
+            return process
+        else: # Process terminated quickly
+            stdout, stderr = process.communicate()
+            logging.error(f"Failed to start Python app {filepath} on port {port}. Exit code: {process.returncode}")
+            logging.error(f"Stdout: {stdout.decode(errors='ignore')}")
+            logging.error(f"Stderr: {stderr.decode(errors='ignore')}")
+            running_apps_processes[app_id]["status"] = "error_starting"
+            del running_apps_processes[app_id] # Clean up
+            return None
+    except Exception as e:
+        logging.error(f"Exception starting Python app {filepath} on port {port}: {e}")
+        if app_id in running_apps_processes: # if entry was made partially
+            running_apps_processes[app_id]["status"] = "error_exception"
+        return None
+
+def stop_python_app(app_id):
+    global running_apps_processes
+    if app_id in running_apps_processes:
+        app_info = running_apps_processes[app_id]
+        process = app_info["process"]
+        try:
+            if process.poll() is None: # If still running
+                process.terminate() # or process.kill()
+                process.wait(timeout=5) # Wait for it to terminate
+                logging.info(f"Python app {app_info['filename']} (PID {process.pid}) on port {app_info['port']} terminated.")
+            else:
+                logging.info(f"Python app {app_info['filename']} was already stopped.")
+            
+            app_info["status"] = "stopped"
+            # Keep the entry in running_apps_processes with status "stopped", or del running_apps_processes[app_id]
+            # For now, let's keep it to reflect it was managed
+            return True
+        except subprocess.TimeoutExpired:
+            logging.warning(f"Timeout trying to terminate app {app_info['filename']}. It might need to be killed manually.")
+            process.kill() # Force kill
+            app_info["status"] = "killed"
+            return False
+        except Exception as e:
+            logging.error(f"Error stopping Python app {app_info['filename']}: {e}")
+            app_info["status"] = "error_stopping"
+            return False
+    return False
+
+def stop_all_running_apps():
+    logging.info("Stopping all managed Python applications...")
+    app_ids_to_stop = list(running_apps_processes.keys()) # Iterate over a copy
+    for app_id in app_ids_to_stop:
+        if running_apps_processes[app_id].get("status") == "running":
+            stop_python_app(app_id)
+    logging.info("Finished stopping applications.")
 
+atexit.register(stop_all_running_apps)
 
-# --- HTML шаблон для главной страницы генератора ---
-# (Взят из Кода 1 и немного адаптирован)
-html_template = """
+
+# --- Flask Routes ---
+html_template_for_generator = """
 <!DOCTYPE html>
 <html lang="ru">
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0, viewport-fit=cover">
-    <title>EVA - Генератор Python Сайтов</title>
+    <title>EVA - Генератор Python Приложений</title>
     <style>
-        :root {
-            --system-gray-100-light: #f2f2f7;
-            --system-gray-75-light: #f8f8fa;
-            --system-gray-50-light: #ffffff;
-            --system-gray-dark-100-light: #000000;
-            --system-gray-dark-75-light: #1c1c1e;
-            --system-gray-dark-50-light: #3a3a3c;
-            --system-gray-light-75-light: #8e8e93;
-            --system-gray-light-50-light: #aeaeb2;
-            --system-blue-light: #007aff;
-            --system-blue-light-hover: #005ecf;
-            --system-red-light: #ff3b30;
-            --system-separator-light: rgba(60, 60, 67, 0.29);
-            --system-separator-opaque-light: #d1d1d6;
-
-            --system-gray-100-dark: #1c1c1e;
-            --system-gray-75-dark: #2c2c2e;
-            --system-gray-50-dark: #000000;
-            --system-gray-dark-100-dark: #ffffff;
-            --system-gray-dark-75-dark: #f2f2f7;
-            --system-gray-dark-50-dark: #e5e5ea;
-            --system-gray-light-75-dark: #8e8e93;
-            --system-gray-light-50-dark: #636366;
-            --system-blue-dark: #0a84ff;
-            --system-blue-dark-hover: #3b9eff;
-            --system-red-dark: #ff453a;
-            --system-separator-dark: rgba(84, 84, 88, 0.65);
-            --system-separator-opaque-dark: #38383a;
+        :root { /* Styles from original Code 1, slightly simplified for brevity */
+            --system-gray-100-light: #f2f2f7; --system-gray-50-light: #ffffff;
+            --system-gray-dark-100-light: #000000; --system-gray-light-75-light: #8e8e93;
+            --system-blue-light: #007aff; --system-blue-light-hover: #005ecf;
+            --system-red-light: #ff3b30; --system-separator-opaque-light: #d1d1d6;
+            --system-gray-100-dark: #1c1c1e; --system-gray-50-dark: #000000;
+            --system-gray-dark-100-dark: #ffffff; --system-gray-light-75-dark: #8e8e93;
+            --system-blue-dark: #0a84ff; --system-blue-dark-hover: #3b9eff;
+            --system-red-dark: #ff453a; --system-separator-opaque-dark: #38383a;
         }
-
         @media (prefers-color-scheme: dark) {
             :root {
-                --bg-color: var(--system-gray-50-dark);
-                --content-bg: var(--system-gray-100-dark);
-                --text-color: var(--system-gray-dark-100-dark);
-                --secondary-text-color: var(--system-gray-light-75-dark);
-                --tertiary-text-color: var(--system-gray-light-50-dark);
-                --border-color: var(--system-separator-dark);
-                --border-color-opaque: var(--system-separator-opaque-dark);
-                --input-bg: var(--system-gray-75-dark);
-                --primary-color: var(--system-blue-dark);
-                --primary-color-hover: var(--system-blue-dark-hover);
+                --bg-color: var(--system-gray-50-dark); --content-bg: var(--system-gray-100-dark);
+                --text-color: var(--system-gray-dark-100-dark); --secondary-text-color: var(--system-gray-light-75-dark);
+                --border-color-opaque: var(--system-separator-opaque-dark); --input-bg: var(--system-gray-100-dark);
+                --primary-color: var(--system-blue-dark); --primary-color-hover: var(--system-blue-dark-hover);
                 --error-color: var(--system-red-dark);
             }
         }
-
         @media (prefers-color-scheme: light) {
             :root {
-                --bg-color: var(--system-gray-100-light);
-                --content-bg: var(--system-gray-50-light);
-                --text-color: var(--system-gray-dark-100-light);
-                --secondary-text-color: var(--system-gray-light-75-light);
-                --tertiary-text-color: var(--system-gray-light-50-light);
-                --border-color: var(--system-separator-light);
-                 --border-color-opaque: var(--system-separator-opaque-light);
-                --input-bg: var(--system-gray-75-light);
-                --primary-color: var(--system-blue-light);
-                --primary-color-hover: var(--system-blue-light-hover);
+                --bg-color: var(--system-gray-100-light); --content-bg: var(--system-gray-50-light);
+                --text-color: var(--system-gray-dark-100-light); --secondary-text-color: var(--system-gray-light-75-light);
+                --border-color-opaque: var(--system-separator-opaque-light); --input-bg: var(--system-gray-100-light);
+                --primary-color: var(--system-blue-light); --primary-color-hover: var(--system-blue-light-hover);
                 --error-color: var(--system-red-light);
             }
         }
-
-        html { height: -webkit-fill-available; }
-        body {
-            font-family: -apple-system, BlinkMacSystemFont, "SF Pro Text", "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
-            margin: 0; padding: 20px env(safe-area-inset-top) 20px env(safe-area-inset-bottom);
-            background-color: var(--bg-color); color: var(--text-color);
-            display: flex; justify-content: center; align-items: flex-start;
-            min-height: 100vh; min-height: -webkit-fill-available;
-            line-height: 1.45; -webkit-font-smoothing: antialiased; -moz-osx-font-smoothing: grayscale;
-        }
-        .container {
-            background-color: var(--content-bg); padding: 25px 30px 30px 30px;
-            border-radius: 24px; box-shadow: 0 12px 28px rgba(0, 0, 0, 0.08), 0 2px 4px rgba(0,0,0,0.05);
-            max-width: 580px; width: calc(100% - 40px); box-sizing: border-box; margin-top: 30px;
-        }
-        h1 { font-size: 32px; font-weight: 700; text-align: center; margin-bottom: 8px; color: var(--text-color); letter-spacing: -0.5px; }
-        p.subtitle { font-size: 17px; color: var(--secondary-text-color); text-align: center; margin-bottom: 35px; font-weight: 400; }
-        .form-group { margin-bottom: 28px; }
-        label.input-label { display: block; font-weight: 500; margin-bottom: 10px; font-size: 15px; color: var(--secondary-text-color); padding-left: 5px; }
-        textarea#prompt-input {
-            width: 100%; padding: 14px 18px; border: 1px solid var(--border-color-opaque); border-radius: 12px;
-            font-size: 16px; background-color: var(--input-bg); color: var(--text-color);
-            box-sizing: border-box; transition: border-color 0.2s ease, box-shadow 0.2s ease;
-            font-family: inherit; resize: vertical; min-height: 120px;
-        }
-        textarea#prompt-input:focus {
-             border-color: var(--primary-color);
-             box-shadow: 0 0 0 3px color-mix(in srgb, var(--primary-color) 25%, transparent);
-             outline: none;
-        }
-        button#generate-button {
-            width: 100%; padding: 16px; background-color: var(--primary-color); color: white;
-            border: none; border-radius: 12px; font-size: 17px; font-weight: 600; cursor: pointer;
-            transition: background-color 0.2s ease, transform 0.1s ease; margin-top: 15px;
-        }
-        button#generate-button:hover { background-color: var(--primary-color-hover); }
-        button#generate-button:active { transform: scale(0.98); }
-        button#generate-button:disabled { background-color: var(--tertiary-text-color); cursor: not-allowed; }
+        body { font-family: -apple-system, BlinkMacSystemFont, "SF Pro Text", "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif; margin: 0; padding: 20px; background-color: var(--bg-color); color: var(--text-color); display: flex; justify-content: center; align-items: flex-start; min-height: 100vh; }
+        .container { background-color: var(--content-bg); padding: 30px; border-radius: 24px; box-shadow: 0 12px 28px rgba(0,0,0,0.08); max-width: 680px; width: calc(100% - 40px); box-sizing: border-box; margin-top: 30px; }
+        h1 { font-size: 32px; font-weight: 700; text-align: center; margin-bottom: 8px; }
+        p.subtitle { font-size: 17px; color: var(--secondary-text-color); text-align: center; margin-bottom: 35px; }
+        textarea { width: 100%; padding: 14px 18px; border: 1px solid var(--border-color-opaque); border-radius: 12px; font-size: 16px; background-color: var(--input-bg); color: var(--text-color); box-sizing: border-box; min-height: 120px; font-family: inherit; }
+        button { width: 100%; padding: 16px; background-color: var(--primary-color); color: white; border: none; border-radius: 12px; font-size: 17px; font-weight: 600; cursor: pointer; transition: background-color 0.2s ease; margin-top: 15px; }
+        button:hover { background-color: var(--primary-color-hover); }
+        button:disabled { background-color: var(--secondary-text-color); cursor: not-allowed; }
         .output-section { margin-top: 35px; }
-        .output-header { display: flex; justify-content: space-between; align-items: center; margin-bottom: 10px; }
-        label#output-label { font-weight: 500; font-size: 15px; color: var(--secondary-text-color); padding-left: 5px; }
-        button#copy-button {
-            background-color: transparent; border: none; color: var(--primary-color);
-            font-size: 14px; font-weight: 500; cursor: pointer; padding: 5px 8px;
-            border-radius: 6px; transition: background-color 0.2s ease, color 0.2s ease; display: none;
-        }
-        button#copy-button:hover { background-color: color-mix(in srgb, var(--primary-color) 15%, transparent); }
-        button#copy-button:active { background-color: color-mix(in srgb, var(--primary-color) 25%, transparent); }
-        button#copy-button.copied { color: #34c759; }
-        @media (prefers-color-scheme: dark) { button#copy-button.copied { color: #30d158; } }
-        #output-container {
-            background-color: var(--input-bg); padding: 18px 20px; border-radius: 12px;
-            min-height: 60px; border: 1px solid var(--border-color); word-wrap: break-word;
-            font-size: 15px; color: var(--text-color); line-height: 1.5;
-            transition: border-color 0.2s ease, background-color 0.2s ease;
-            display: flex; align-items: center; justify-content: center;
-        }
-        #output-container a { color: var(--primary-color); text-decoration: none; font-weight: 500; }
+        #output-container { background-color: var(--input-bg); padding: 18px 20px; border-radius: 12px; min-height: 60px; border: 1px solid var(--border-color-opaque); word-wrap: break-word; font-size: 15px; display: flex; align-items: center; justify-content: center; }
+        #output-container a { color: var(--primary-color); text-decoration: none; font-weight: 500; margin: 0 10px; }
         #output-container a:hover { text-decoration: underline; }
-        #output-container.loading::before {
-            content: "Генерация сайта..."; display: block; text-align: center;
-            font-style: italic; color: var(--secondary-text-color); animation: fadePulse 1.8s infinite ease-in-out;
-        }
-        #output-container.error {
-            color: var(--error-color); font-weight: 500;
-            border-color: color-mix(in srgb, var(--error-color) 50%, transparent);
-            background-color: color-mix(in srgb, var(--error-color) 10%, var(--input-bg));
-            justify-content: flex-start;
-        }
-        @keyframes fadePulse { 0%, 100% { opacity: 0.6; } 50% { opacity: 1; } }
-        @media (max-width: 620px) {
-            body { padding: 15px env(safe-area-inset-top) 15px env(safe-area-inset-bottom); align-items: flex-start; }
-            .container { padding: 20px 20px 25px 20px; margin-top: 15px; border-radius: 20px; width: calc(100% - 30px); }
-            h1 { font-size: 28px; }
-            p.subtitle { font-size: 16px; margin-bottom: 25px; }
-            .form-group { margin-bottom: 22px; }
-            textarea#prompt-input { padding: 12px 15px; min-height: 100px; }
-            button#generate-button { padding: 15px; font-size: 16px; }
-            #output-container { padding: 15px 18px; font-size: 14px; min-height: 50px; }
-            .output-section { margin-top: 30px; }
-        }
+        #output-container.loading::before { content: "Генерация приложения..."; display: block; text-align: center; color: var(--secondary-text-color); }
+        #output-container.error { color: var(--error-color); font-weight: 500; justify-content: flex-start; }
+        .form-group { margin-bottom: 20px; }
+        label { display: block; font-weight: 500; margin-bottom: 8px; font-size: 15px; color: var(--secondary-text-color); }
+         .sync-buttons { display: flex; gap: 10px; margin-bottom: 20px; justify-content: center; }
+        .sync-buttons button { width: auto; padding: 10px 15px; font-size: 14px; margin-top: 0; }
+        .app-list { margin-top: 20px; padding-top: 20px; border-top: 1px solid var(--border-color-opaque); }
+        .app-item { background-color: var(--input-bg); padding: 10px 15px; border-radius: 8px; margin-bottom: 10px; font-size: 14px; }
+        .app-item strong {color: var(--primary-color); }
     </style>
 </head>
 <body>
     <div class="container">
         <h1>EVA</h1>
-        <p class="subtitle">Генератор Python Flask сайтов</p>
+        <p class="subtitle">Генератор Python Flask Приложений</p>
+        
+        <div class="sync-buttons">
+            <form method="POST" action="{{ url_for('force_sync_to_hf_route') }}" style="display: inline;">
+                <button type="submit" title="Сохранить текущее состояние (манифест и приложения) в Hugging Face">Сохранить на HF</button>
+            </form>
+            <form method="POST" action="{{ url_for('force_sync_from_hf_route') }}" style="display: inline;">
+                <button type="submit" title="Загрузить последнее состояние (манифест и приложения) из Hugging Face">Загрузить с HF</button>
+            </form>
+        </div>
 
         <form id="generate-form">
             <div class="form-group">
-                <label for="prompt-input" class="input-label">Опишите сайт, который вы хотите создать (на Python/Flask)</label>
-                <textarea id="prompt-input" name="prompt" rows="6" required placeholder="Например: создай простой одностраничный сайт-визитку на Flask. На главной странице должен быть заголовок 'Мой Сайт', текст 'Добро пожаловать!' и текущее время."></textarea>
+                <label for="prompt-input">Опишите приложение, которое вы хотите создать:</label>
+                <textarea id="prompt-input" name="prompt" rows="6" required placeholder="Например: создай простое Flask приложение с одной страницей, которое показывает текущее время."></textarea>
             </div>
-            <button type="submit" id="generate-button">Создать сайт</button>
+            <button type="submit" id="generate-button">Создать приложение</button>
         </form>
 
         <div class="output-section">
-             <div class="output-header">
-                 <label id="output-label">Ссылка для запуска сайта</label>
-                 <button id="copy-button">Копировать</button>
-             </div>
+            <label>Результат генерации:</label>
             <div id="output-container" aria-live="polite"></div>
         </div>
+        
+        <div class="app-list">
+            <h2>Сгенерированные Приложения</h2>
+            <div id="apps-display-list">
+                <!-- App items will be injected here by JS if needed, or server-rendered -->
+                {% if apps_manifest and apps_manifest|length > 0 %}
+                    {% for app_id, app_info in apps_manifest.items() %}
+                    <div class="app-item">
+                        <strong>ID:</strong> {{ app_id }}<br>
+                        <strong>Файл:</strong> {{ app_info.filename }} (Порт: {{ app_info.port or 'N/A' }})<br>
+                        <strong>Статус:</strong> {{ running_apps_processes.get(app_id, {}).get('status', app_info.status_on_generator or 'неизвестно') }} <br>
+                        <strong>Запрос:</strong> {{ app_info.prompt[:80] }}{% if app_info.prompt|length > 80 %}...{% endif %}<br>
+                        {% if running_apps_processes.get(app_id, {}).get('status') == 'running' and app_info.port %}
+                            <a href="http://localhost:{{ app_info.port }}" target="_blank">Открыть приложение</a>
+                        {% endif %}
+                         <a href="{{ url_for('serve_generated_app_file', filename=app_info.filename) }}">Скачать .py</a>
+                        <!-- Add stop/start buttons here if implementing full management -->
+                    </div>
+                    {% endfor %}
+                {% else %}
+                    <p>Пока нет сгенерированных приложений.</p>
+                {% endif %}
+            </div>
+        </div>
     </div>
 
     <script>
@@ -533,94 +560,84 @@ html_template = """
         const promptInput = document.getElementById('prompt-input');
         const outputContainer = document.getElementById('output-container');
         const generateButton = document.getElementById('generate-button');
-        const copyButton = document.getElementById('copy-button');
 
         form.addEventListener('submit', async (event) => {
             event.preventDefault();
             if (!promptInput.value.trim()) {
-                showError("Пожалуйста, опишите сайт, который вы хотите создать.");
+                outputContainer.textContent = "Пожалуйста, опишите приложение.";
+                outputContainer.className = 'error';
                 return;
             }
             const formData = new FormData(form);
             generateButton.disabled = true;
             generateButton.textContent = 'Генерация...';
             outputContainer.innerHTML = '';
-            outputContainer.classList.add('loading');
-            outputContainer.classList.remove('error');
-            copyButton.style.display = 'none';
-            copyButton.textContent = 'Копировать';
-            copyButton.classList.remove('copied');
+            outputContainer.className = 'loading';
 
             try {
-                const response = await fetch('/generate', { method: 'POST', body: formData });
+                const response = await fetch("{{ url_for('handle_generate_python_app') }}", {
+                    method: 'POST',
+                    body: formData
+                });
                 const result = await response.json();
 
                 if (!response.ok) {
                     throw new Error(result.error || `Ошибка сервера: ${response.status}`);
                 }
 
-                if (result.site_run_url) { // Изменено с site_url на site_run_url
-                    const link = document.createElement('a');
-                    link.href = result.site_run_url;
-                    link.textContent = "Запустить и открыть сгенерированный сайт";
-                    link.target = "_blank"; // Откроет в новой вкладке, что приведет к редиректу
-                    outputContainer.innerHTML = '';
-                    outputContainer.appendChild(link);
-                    copyButton.style.display = 'block';
-                    copyButton.dataset.copyText = window.location.origin + result.site_run_url;
+                if (result.app_id && result.filename) {
+                    let html = \`Приложение создано (ID: \${result.app_id}): \${result.filename}\`;
+                    if (result.app_url) {
+                        html += \`<br><a href="\${result.app_url}" target="_blank">Открыть работающее приложение (порт \${result.port})</a>\`;
+                    } else if (result.start_error){
+                        html += \`<br><span style="color:red;">Ошибка запуска: \${result.start_error}</span>\`;
+                    }
+                    html += \`<br><a href="\${result.download_url}" target="_blank">Скачать \${result.filename}</a>\`;
+                    outputContainer.innerHTML = html;
+                    outputContainer.className = ''; 
+                    // Optionally refresh the app list below or redirect to update it
+                    window.location.reload(); // Simple way to refresh the list
                 } else if (result.error) {
-                    showError(result.error);
+                    outputContainer.textContent = result.error;
+                    outputContainer.className = 'error';
                 } else {
-                    showError("Не удалось получить ссылку на сайт. Ответ сервера не содержит URL.");
+                    outputContainer.textContent = "Неожиданный ответ от сервера.";
+                    outputContainer.className = 'error';
                 }
             } catch (error) {
                 console.error("Fetch Error:", error);
-                showError(`Ошибка: ${error.message}`);
+                outputContainer.textContent = \`Ошибка: \${error.message}\`;
+                outputContainer.className = 'error';
             } finally {
                 generateButton.disabled = false;
-                generateButton.textContent = 'Создать сайт';
-                outputContainer.classList.remove('loading');
+                generateButton.textContent = 'Создать приложение';
+                 if (outputContainer.classList.contains('loading')) { // if not set by success/error
+                    outputContainer.classList.remove('loading');
+                 }
             }
         });
-
-        copyButton.addEventListener('click', () => {
-            const textToCopy = copyButton.dataset.copyText;
-            if (!textToCopy) return;
-            navigator.clipboard.writeText(textToCopy).then(() => {
-                copyButton.textContent = 'Скопировано!';
-                copyButton.classList.add('copied');
-                setTimeout(() => {
-                     copyButton.textContent = 'Копировать';
-                     copyButton.classList.remove('copied');
-                }, 1500);
-            }).catch(err => {
-                console.error('Ошибка копирования: ', err);
-                copyButton.textContent = 'Ошибка';
-                 setTimeout(() => { copyButton.textContent = 'Копировать'; }, 1500);
-            });
-        });
-
-        function showError(message) {
-             outputContainer.innerHTML = ''; 
-             const errorMessageElement = document.createElement('span');
-             errorMessageElement.textContent = message;
-             outputContainer.appendChild(errorMessageElement);
-             outputContainer.classList.add('error');
-             outputContainer.classList.remove('loading');
-             copyButton.style.display = 'none';
-        }
     </script>
 </body>
 </html>
 """
 
-# --- Маршруты Flask основного приложения ---
 @app.route('/')
 def index():
-    return Response(html_template, mimetype='text/html')
+    manifest = load_apps_manifest()
+    # Pass running_apps_processes to template for dynamic status if needed
+    # For simplicity, status in manifest can be 'last known status'
+    return render_template_string(html_template_for_generator, apps_manifest=manifest, running_apps_processes=running_apps_processes)
+
+@app.route('/apps/<filename>')
+def serve_generated_app_file(filename):
+    safe_filename = secure_filename(filename)
+    if not safe_filename.endswith(".py"):
+        return "Invalid file type", 400
+    return send_from_directory(GENERATED_APPS_DIR, safe_filename, as_attachment=True)
+
 
 @app.route('/generate', methods=['POST'])
-def handle_generate():
+def handle_generate_python_app():
     if 'prompt' not in request.form:
         return jsonify({"error": "Текстовый запрос (промпт) не найден."}), 400
 
@@ -629,77 +646,109 @@ def handle_generate():
          return jsonify({"error": "Текстовый запрос не может быть пустым."}), 400
 
     try:
-        python_code = generate_full_python_site_from_prompt(user_prompt)
+        python_code = generate_python_app_from_prompt(user_prompt)
         
         if not python_code or not python_code.strip():
             return jsonify({"error": "Сгенерированный Python-код пуст."}), 500
 
-        # Генерируем уникальное имя файла для .py сайта
-        site_filename = f"site_{uuid.uuid4().hex[:12]}.py"
-        local_filepath = os.path.join(SITES_CACHE_DIR, site_filename)
+        app_id = str(uuid.uuid4())
+        filename = f"app_{app_id[:8]}.py" # Shorter filename
+        filepath = os.path.join(GENERATED_APPS_DIR, filename)
         
-        with open(local_filepath, "w", encoding="utf-8") as f:
+        with open(filepath, "w", encoding="utf-8") as f:
             f.write(python_code)
-        logging.info(f"Сгенерированный сайт сохранен локально: {local_filepath}")
-            
-        # Загружаем на Hugging Face
-        repo_filepath = f"sites/{site_filename}" # Путь в репозитории HF
-        if upload_file_to_hf(local_filepath, repo_filepath):
-            logging.info(f"Сайт {site_filename} успешно загружен на Hugging Face: {REPO_ID}/{repo_filepath}")
-        else:
-            # Не фатально, сайт все еще может работать из локального кэша, но не будет синхронизирован
-            logging.warning(f"Не удалось загрузить сайт {site_filename} на Hugging Face.")
-
-
-        # Ссылка для запуска сайта (которая приведет к редиректу на его порт)
-        site_run_url = url_for('run_generated_site', filename=site_filename, _external=False)
-        return jsonify({"site_run_url": site_run_url})
+        
+        assigned_port = get_next_app_port()
+        process = start_python_app(app_id, filepath, assigned_port)
+        
+        app_url = None
+        start_error_msg = None
+        current_status = "stopped_or_error"
+
+        if process:
+            app_url = f"http://localhost:{assigned_port}"
+            current_status = "running"
+        else: # Failed to start
+            start_error_msg = f"Не удалось запустить приложение {filename} на порту {assigned_port}."
+            current_status = "error_starting"
+
+
+        # Update manifest
+        manifest = load_apps_manifest()
+        manifest[app_id] = {
+            "filename": filename,
+            "prompt": user_prompt,
+            "port": assigned_port if process else None,
+            "created_at": datetime.now().isoformat(),
+            "status_on_generator": current_status, # "running", "error_starting", "stopped" (if we add stop UI)
+            "hf_path_py": f"{HF_APPS_DIR_IN_REPO}/{filename}"
+        }
+        save_apps_manifest(manifest)
 
-    except ValueError as ve: # Ошибки валидации или от GenAI
-        logging.error(f"ValueError during site generation: {str(ve)}")
-        return jsonify({"error": str(ve)}), 400 # 400 Bad Request или 422 Unprocessable Entity
+        # Sync to Hugging Face
+        sync_manifest_to_hf()
+        sync_app_py_file_to_hf(app_id, manifest)
+            
+        return jsonify({
+            "app_id": app_id,
+            "filename": filename,
+            "port": assigned_port,
+            "app_url": app_url,
+            "download_url": url_for('serve_generated_app_file', filename=filename, _external=False),
+            "start_error": start_error_msg
+        })
+
+    except ValueError as ve: # From AI generation or validation
+        return jsonify({"error": str(ve)}), 400
     except Exception as e:
-        logging.error(f"Unexpected error during site generation: {e}", exc_info=True)
-        return jsonify({"error": f"Внутренняя ошибка сервера при генерации сайта: {e}"}), 500
+        logging.error(f"Unexpected error during Python app generation: {e}", exc_info=True)
+        return jsonify({"error": f"Внутренняя ошибка сервера: {e}"}), 500
+
+# --- Routes for manual sync (can be called from UI buttons) ---
+@app.route('/admin/sync_to_hf', methods=['POST'])
+def force_sync_to_hf_route():
+    logging.info("Forcing full sync to Hugging Face...")
+    manifest = load_apps_manifest()
+    sync_manifest_to_hf()
+    for app_id in manifest:
+        sync_app_py_file_to_hf(app_id, manifest)
+    flash("Синхронизация с Hugging Face (выгрузка) завершена.", "success")
+    return redirect(url_for('index'))
+
+@app.route('/admin/sync_from_hf', methods=['POST'])
+def force_sync_from_hf_route():
+    logging.info("Forcing full sync from Hugging Face...")
+    initial_sync_from_hf() # This re-downloads manifest and missing apps
+    # Note: This doesn't automatically (re)start downloaded apps. That would be an enhancement.
+    flash("Синхронизация с Hugging Face (загрузка) завершена. Перезагрузите страницу, чтобы увидеть изменения.", "info")
+    return redirect(url_for('index'))
+
 
-@app.route('/run_site/<filename>')
-def run_generated_site(filename):
-    if not filename.endswith(".py"):
-        return "Неверное имя файла сайта.", 400
+if __name__ == '__main__':
+    # Initial sync when the app starts
+    initial_sync_from_hf()
     
-    logging.info(f"Запрос на запуск сайта: {filename}")
-    site_host, site_port = start_generated_site(filename)
-
-    if site_host and site_port:
-        # Формируем URL для редиректа. request.host содержит <host>:<port> основного приложения.
-        # Нам нужен только хост.
-        main_app_host = request.host.split(':')[0]
-        # Если основной сервер слушает на 0.0.0.0, браузер обычно обращается через localhost или конкретный IP.
-        # Используем main_app_host, чтобы редирект был на тот же хост, с которого пришел запрос.
-        # Если site_host это '127.0.0.1', а main_app_host это '0.0.0.0' или реальный IP,
-        # редирект на 127.0.0.1 может сработать только локально.
-        # Для простоты, если main_app_host '0.0.0.0', заменим на '127.0.0.1' для URL редиректа.
-        if main_app_host == '0.0.0.0':
-            redirect_host = '127.0.0.1'
-        else:
-            redirect_host = main_app_host
+    # Start periodic backup thread if HF_TOKEN_WRITE is available
+    if HF_TOKEN_WRITE:
+        backup_thread = threading.Thread(target=lambda: {
+            logging.info("Periodic backup thread started."),
+            initial_sync_from_hf(), # Ensure we have the latest before starting periodic saves
+            periodic_backup_job() # First backup immediate
+        }, daemon=True)
+
+        def run_periodic_backup_loop():
+            while True:
+                time.sleep(BACKUP_INTERVAL_SECONDS)
+                periodic_backup_job()
+        
+        loop_thread = threading.Thread(target=run_periodic_backup_loop, daemon=True)
+        
+        backup_thread.start() # initial sync and first backup
+        loop_thread.start() # starts the loop
 
-        redirect_url = f"http://{redirect_host}:{site_port}/"
-        logging.info(f"Редирект на запущенный сайт: {redirect_url}")
-        return redirect(redirect_url, code=302)
     else:
-        logging.error(f"Не удалось запустить сайт {filename}.")
-        # Можно вернуть страницу с ошибкой
-        return f"Не удалось запустить сайт {filename}. Проверьте логи сервера.", 500
+        logging.warning("HF_TOKEN_WRITE not set. Periodic backup to Hugging Face will NOT run.")
 
-
-if __name__ == '__main__':
-    # Проверка наличия HF_TOKEN_WRITE для загрузки на HF
-    if not HF_TOKEN_WRITE:
-        logging.warning("Переменная окружения HF_TOKEN (с правом записи) не установлена. "
-                        "Сгенерированные сайты не будут загружаться на Hugging Face.")
-    
-    # Порт для основного приложения-генератора
-    main_app_port = 7860
-    logging.info(f"Основное приложение генератора запускается на порту {main_app_port}")
-    app.run(host='0.0.0.0', port=main_app_port, debug=False)
+    main_app_port = int(os.getenv("MAIN_APP_PORT", 7860))
+    logging.info(f"EVA - Python App Generator starting on http://localhost:{main_app_port}")
+    app.run(host='0.0.0.0', port=main_app_port, debug=False) # Debug False for production/multiple processes