app.py

#!/usr/bin/env python3
import os
import subprocess
import sys
import time
import json
from pathlib import Path
import signal
import threading
import shutil
import logging
import urllib.request
import urllib.error
import tempfile
import http.server
import socketserver
from typing import Dict, Any, Optional, Union

# Настройка логирования
logging.basicConfig(level=logging.INFO, 
                    format='%(asctime)s [%(levelname)s] %(message)s',
                    datefmt='%Y-%m-%d %H:%M:%S')

logger = logging.getLogger('ten-agent')

# Глобальные пути
AGENTS_DIR = Path("/app/agents")
PROPERTY_JSON = AGENTS_DIR / "property.json"
MANIFEST_JSON = AGENTS_DIR / "manifest.json"
VOICE_AGENT_JSON = AGENTS_DIR / "voice_agent.json" 
CHAT_AGENT_JSON = AGENTS_DIR / "chat_agent.json"
API_BINARY = Path("/app/server/bin/api")
PLAYGROUND_DIR = Path("/app/playground")
BACKUP_DIR = Path("/app/backup")

# Глобальные переменные
PROXY_PORT = 9090  # Порт для прокси-сервера
API_PORT = 8080    # Порт для API сервера

def ensure_directory_permissions(directory_path):
    """Обеспечиваем правильные разрешения для директории"""
    directory = Path(directory_path)
    if not directory.exists():
        logger.info(f"Создание директории {directory}")
        directory.mkdir(parents=True, exist_ok=True)
    
    # Устанавливаем полные права
    subprocess.run(["chmod", "-R", "777", str(directory)])
    logger.info(f"Права доступа для {directory} установлены")

def backup_file(filepath):
    """Создает резервную копию файла"""
    src_path = Path(filepath)
    if not src_path.exists():
        logger.warning(f"Невозможно создать резервную копию: {filepath} не существует")
        return
    
    BACKUP_DIR.mkdir(parents=True, exist_ok=True)
    dest_path = BACKUP_DIR / f"{src_path.name}.bak"
    
    try:
        shutil.copy2(src_path, dest_path)
        logger.info(f"Резервная копия создана: {dest_path}")
    except Exception as e:
        logger.error(f"Ошибка при создании резервной копии {filepath}: {e}")

def update_property_json():
    """Проверяет существующий property.json и добавляет поле predefined_graphs, если его нет"""
    if not PROPERTY_JSON.exists():
        logger.info(f"{PROPERTY_JSON} не существует, нет необходимости в обновлении")
        return False
    
    try:
        with open(PROPERTY_JSON, 'r') as f:
            data = json.load(f)
        
        need_update = False
        
        # Проверяем наличие predefined_graphs и его формат
        if "predefined_graphs" not in data:
            logger.info(f"{PROPERTY_JSON} не содержит поле predefined_graphs")
            need_update = True
        elif not isinstance(data["predefined_graphs"], list):
            logger.warning(f"{PROPERTY_JSON} содержит predefined_graphs, но это не массив")
            need_update = True
        
        if not need_update:
            logger.info(f"{PROPERTY_JSON} уже содержит корректное поле predefined_graphs")
            return False
        
        # Создаем резервную копию перед изменением
        backup_file(PROPERTY_JSON)
        
        # Создаем полностью новый property.json с правильной структурой
        property_data = {
            "_ten": {},
            "name": "TEN Agent Example",
            "version": "0.0.1",
            "extensions": ["openai_chatgpt"],
            "description": "A basic voice agent with OpenAI",
            "predefined_graphs": [
                {
                    "name": "Voice Agent",
                    "description": "Basic voice agent with OpenAI",
                    "file": "voice_agent.json"
                },
                {
                    "name": "Chat Agent",
                    "description": "Simple chat agent",
                    "file": "chat_agent.json"
                }
            ]
        }
        
        # Если есть другие поля в оригинальном файле, сохраняем их
        for key, value in data.items():
            if key not in property_data and key != "predefined_graphs" and key != "graphs":
                property_data[key] = value
        
        # Добавляем поле graphs в конец для совместимости
        property_data["graphs"] = property_data["predefined_graphs"]
        
        # Сохраняем обновленный файл
        with open(PROPERTY_JSON, 'w') as f:
            json.dump(property_data, f, indent=2)
        
        logger.info(f"{PROPERTY_JSON} успешно обновлен с корректным полем predefined_graphs")
        return True
    except Exception as e:
        logger.error(f"Ошибка при обновлении {PROPERTY_JSON}: {e}")
        return False

def check_and_create_property_json():
    """Проверяет наличие property.json и создает его при необходимости"""
    if not PROPERTY_JSON.exists():
        logger.warning(f"{PROPERTY_JSON} не найден, создаем файл...")
        
        property_data = {
            "_ten": {},  # Важное поле для TEN формата
            "name": "TEN Agent Example",
            "version": "0.0.1",
            "extensions": ["openai_chatgpt"],
            "description": "A basic voice agent with OpenAI",
            "predefined_graphs": [  # Важное поле, которое ожидает API
                {
                    "name": "Voice Agent",
                    "description": "Basic voice agent with OpenAI",
                    "file": "voice_agent.json"
                },
                {
                    "name": "Chat Agent",
                    "description": "Simple chat agent",
                    "file": "chat_agent.json"
                }
            ],
            "graphs": [
                {
                    "name": "Voice Agent",
                    "description": "Basic voice agent with OpenAI",
                    "file": "voice_agent.json"
                },
                {
                    "name": "Chat Agent",
                    "description": "Simple chat agent",
                    "file": "chat_agent.json"
                }
            ]
        }
        
        # Проверяем и создаем директории
        PROPERTY_JSON.parent.mkdir(parents=True, exist_ok=True)
        
        # Создаем временный файл и затем перемещаем его
        with tempfile.NamedTemporaryFile(mode='w', delete=False) as temp_file:
            json.dump(property_data, temp_file, indent=2)
            temp_path = temp_file.name
        
        # Копируем временный файл в целевой
        try:
            shutil.copy2(temp_path, PROPERTY_JSON)
            os.chmod(PROPERTY_JSON, 0o666)  # Устанавливаем права доступа rw-rw-rw-
            logger.info(f"Файл {PROPERTY_JSON} создан успешно")
        except Exception as e:
            logger.error(f"Ошибка при создании {PROPERTY_JSON}: {e}")
        finally:
            os.unlink(temp_path)  # Удаляем временный файл

def check_and_create_agent_files():
    """Проверяет наличие всех необходимых файлов агентов и создает их при необходимости"""
    
    # Создаем manifest.json если он не существует
    if not MANIFEST_JSON.exists():
        manifest_data = {
            "name": "default",
            "agents": [
                {
                    "name": "voice_agent",
                    "description": "A simple voice agent"
                },
                {
                    "name": "chat_agent",
                    "description": "A text chat agent"
                }
            ]
        }
        
        with open(MANIFEST_JSON, 'w') as f:
            json.dump(manifest_data, f, indent=2)
        os.chmod(MANIFEST_JSON, 0o666)
        logger.info(f"Файл {MANIFEST_JSON} создан")
    
    # Создаем voice_agent.json если он не существует
    if not VOICE_AGENT_JSON.exists():
        voice_agent_data = {
            "nodes": [],
            "edges": [],
            "groups": [],
            "templates": [],
            "root": None
        }
        
        with open(VOICE_AGENT_JSON, 'w') as f:
            json.dump(voice_agent_data, f, indent=2)
        os.chmod(VOICE_AGENT_JSON, 0o666)
        logger.info(f"Файл {VOICE_AGENT_JSON} создан")
    
    # Создаем chat_agent.json если он не существует
    if not CHAT_AGENT_JSON.exists():
        chat_agent_data = {
            "nodes": [],
            "edges": [],
            "groups": [],
            "templates": [],
            "root": None
        }
        
        with open(CHAT_AGENT_JSON, 'w') as f:
            json.dump(chat_agent_data, f, indent=2)
        os.chmod(CHAT_AGENT_JSON, 0o666)
        logger.info(f"Файл {CHAT_AGENT_JSON} создан")

def check_files():
    """Проверяет и выводит информацию о важных файлах"""
    files_to_check = [
        PROPERTY_JSON,
        MANIFEST_JSON,
        VOICE_AGENT_JSON,
        CHAT_AGENT_JSON,
        API_BINARY
    ]
    
    logger.info("=== Проверка критических файлов ===")
    for file_path in files_to_check:
        path = Path(file_path)
        if path.exists():
            if path.is_file():
                size = path.stat().st_size
                logger.info(f"✅ {file_path} (размер: {size} байт)")
                
                # Если это JSON файл, выводим его содержимое
                if str(file_path).endswith('.json'):
                    try:
                        with open(file_path, 'r') as f:
                            content = json.load(f)
                        logger.info(f"   Содержимое: {json.dumps(content, indent=2)}")
                    except Exception as e:
                        logger.error(f"   Ошибка чтения JSON: {e}")
            else:
                logger.warning(f"❌ {file_path} (это директория, а не файл)")
        else:
            logger.error(f"❌ {file_path} (файл не найден)")
    
    logger.info("=== Проверка структуры директорий ===")
    logger.info(f"Содержимое {AGENTS_DIR}:")
    subprocess.run(["ls", "-la", str(AGENTS_DIR)])
    
    logger.info("Проверка прав доступа:")
    subprocess.run(["stat", str(AGENTS_DIR)])
    subprocess.run(["stat", str(PROPERTY_JSON)])

def analyze_api_response(response_data):
    """Анализирует ответ API и выводит диагностическую информацию"""
    try:
        # Пробуем распарсить JSON
        if not response_data or response_data.strip() == "":
            logger.error("API вернул пустой ответ")
            return None
        
        json_data = json.loads(response_data)
        
        # Проверяем тип данных
        if isinstance(json_data, list):
            logger.info(f"API вернул список с {len(json_data)} элементами")
            if len(json_data) > 0:
                logger.info(f"Структура первого элемента: {json.dumps(json_data[0], indent=2)}")
            return json_data
        elif isinstance(json_data, dict):
            logger.info(f"API вернул словарь с ключами: {list(json_data.keys())}")
            # Проверяем наличие кода ошибки
            if "code" in json_data:
                logger.error(f"API вернул ошибку с кодом: {json_data['code']}")
                if "msg" in json_data:
                    logger.error(f"Сообщение ошибки: {json_data['msg']}")
            return json_data
        else:
            logger.warning(f"API вернул неожиданный тип данных: {type(json_data)}")
            return json_data
    except json.JSONDecodeError as e:
        logger.error(f"Ошибка декодирования JSON: {e}")
        logger.error(f"Сырые данные: {response_data}")
        return None
    except Exception as e:
        logger.error(f"Ошибка при анализе ответа API: {e}")
        return None

def test_api():
    """Делает запрос к API для получения списка графов"""
    logger.info("=== Тестирование API ===")
    try:
        # Даем серверу время запуститься
        time.sleep(3)
        
        # Сначала проверяем прокси-сервер
        try:
            proxy_url = f"http://localhost:{PROXY_PORT}/graphs"
            logger.info(f"Проверка прокси-сервера по адресу: {proxy_url}")
            with urllib.request.urlopen(proxy_url) as response:
                data = response.read().decode('utf-8')
                logger.info(f"Ответ прокси-сервера: {data}")
                json_data = analyze_api_response(data)
                if json_data and isinstance(json_data, list) and len(json_data) > 0:
                    logger.info("Прокси-сервер возвращает корректные данные о графах")
                    return
        except Exception as e:
            logger.warning(f"Ошибка при проверке прокси-сервера: {e}")
        
        # Затем проверяем основной API
        with urllib.request.urlopen("http://localhost:8080/graphs") as response:
            data = response.read().decode('utf-8')
            logger.info(f"Ответ /graphs: {data}")
            
            # Анализируем ответ API
            json_data = analyze_api_response(data)
            
            # Проверяем структуру ответа и реагируем на проблемы
            if json_data is None:
                logger.error("Не удалось проанализировать ответ API")
                # Исправляем property.json и перезапускаем API
                generate_fresh_property_json()
                restart_api_server()
            elif isinstance(json_data, list):
                if len(json_data) > 0:
                    logger.info(f"API вернул {len(json_data)} графов")
                else:
                    logger.warning("API вернул пустой список графов")
                    # Пробуем исправить property.json, если он уже существует
                    if PROPERTY_JSON.exists():
                        logger.info("Пробуем обновить существующий property.json...")
                        if update_property_json():
                            restart_api_server()
            elif isinstance(json_data, dict) and "code" in json_data:
                logger.warning("API вернул ошибку, исправляем property.json")
                generate_fresh_property_json()
                restart_api_server()
    except urllib.error.URLError as e:
        logger.error(f"Ошибка запроса к API: {e}")
    except Exception as e:
        logger.error(f"Неизвестная ошибка при запросе к API: {e}")

def generate_fresh_property_json():
    """Создает полностью новый property.json с оптимальной структурой"""
    logger.info("Создание нового property.json с оптимальной структурой")
    
    # Создаем резервную копию существующего файла, если он есть
    if PROPERTY_JSON.exists():
        backup_file(PROPERTY_JSON)
    
    # Создаем новый property.json с правильным порядком полей
    property_data = {
        "_ten": {},
        "name": "TEN Agent Example",
        "version": "0.0.1",
        "extensions": ["openai_chatgpt"],
        "description": "A basic voice agent with OpenAI",
        "predefined_graphs": [
            {
                "name": "Voice Agent",
                "description": "Basic voice agent with OpenAI",
                "file": "voice_agent.json"
            },
            {
                "name": "Chat Agent",
                "description": "Simple chat agent",
                "file": "chat_agent.json"
            }
        ],
        "graphs": [
            {
                "name": "Voice Agent",
                "description": "Basic voice agent with OpenAI",
                "file": "voice_agent.json"
            },
            {
                "name": "Chat Agent",
                "description": "Simple chat agent",
                "file": "chat_agent.json"
            }
        ]
    }
    
    # Создаем временный файл и затем перемещаем его
    with tempfile.NamedTemporaryFile(mode='w', delete=False) as temp_file:
        json.dump(property_data, temp_file, indent=2)
        temp_path = temp_file.name
    
    # Копируем временный файл в целевой
    try:
        shutil.copy2(temp_path, PROPERTY_JSON)
        try:
            os.chmod(PROPERTY_JSON, 0o666)  # Устанавливаем права доступа rw-rw-rw-
        except Exception as e:
            logger.warning(f"Невозможно изменить права доступа для {PROPERTY_JSON}: {e}")
        logger.info(f"Новый файл {PROPERTY_JSON} создан успешно")
    except Exception as e:
        logger.error(f"Ошибка при создании {PROPERTY_JSON}: {e}")
    finally:
        os.unlink(temp_path)  # Удаляем временный файл

def restart_api_server():
    """Перезапускает API сервер"""
    logger.info("Перезапускаем API сервер...")
    
    # Останавливаем текущий процесс
    try:
        subprocess.run(["pkill", "-f", str(API_BINARY)])
        time.sleep(1)
    except Exception as e:
        logger.warning(f"Ошибка при остановке API сервера: {e}")
    
    # Запускаем новый процесс
    try:
        new_process = subprocess.Popen([str(API_BINARY)])
        logger.info("API сервер успешно перезапущен")
        time.sleep(2)  # Даем время для запуска
        return new_process
    except Exception as e:
        logger.error(f"Ошибка при запуске API сервера: {e}")
        return None

def run_simple_proxy():
    """Запускает встроенный прокси-сервер"""
    import http.server
    import socketserver
    import json
    
    # Предварительно подготовленные данные для графов - формат правильный
    GRAPHS_DATA = [
        {
            "name": "Voice Agent",
            "description": "Voice Agent with OpenAI",
            "file": "voice_agent.json",
            "id": "voice_agent",
            "package": "default"
        },
        {
            "name": "Chat Agent",
            "description": "Chat Agent",
            "file": "chat_agent.json",
            "id": "chat_agent",
            "package": "default"
        }
    ]
    
    # Предварительно подготовленные данные для API дизайнера
    DESIGNER_DATA = {
        "success": True,
        "packages": [
            {
                "name": "default",
                "description": "Default package",
                "graphs": [
                    {
                        "name": "Voice Agent",
                        "description": "Voice Agent with OpenAI",
                        "file": "voice_agent.json",
                        "id": "voice_agent",
                        "package": "default"
                    },
                    {
                        "name": "Chat Agent",
                        "description": "Chat Agent",
                        "file": "chat_agent.json",
                        "id": "chat_agent",
                        "package": "default"
                    }
                ]
            }
        ]
    }
    
    class SimpleProxyHandler(http.server.BaseHTTPRequestHandler):
        def do_GET(self):
            logger.info(f"PROXY: GET запрос: {self.path}")
            
            # Для запросов к /graphs ВСЕГДА возвращаем заранее подготовленный ответ
            if self.path == "/graphs":
                logger.info("PROXY: Возвращаем заготовленные данные о графах")
                self._send_response(200, json.dumps(GRAPHS_DATA))
                return
            
            # Для запросов к Designer API ВСЕГДА возвращаем заранее подготовленный ответ
            if self.path.startswith("/api/designer/") or self.path.startswith("/api/dev/"):
                logger.info(f"PROXY: Обработка запроса к Designer API: {self.path}")
                self._send_response(200, json.dumps(DESIGNER_DATA))
                return
            
            # Для других запросов пробуем проксировать на API сервер
            try:
                self._proxy_to_api("GET")
            except Exception as e:
                logger.error(f"PROXY: Ошибка при проксировании GET запроса: {e}")
                # В случае ошибки возвращаем базовый успешный ответ
                self._send_response(200, json.dumps({"success": True}))
        
        def do_POST(self):
            logger.info(f"PROXY: POST запрос: {self.path}")
            
            # Для запросов к Designer API ВСЕГДА возвращаем заранее подготовленный ответ
            if self.path.startswith("/api/designer/") or self.path.startswith("/api/dev/"):
                logger.info(f"PROXY: Обработка POST запроса к Designer API: {self.path}")
                self._send_response(200, json.dumps({"success": True}))
                return
            
            # Для других запросов пробуем проксировать на API сервер
            try:
                self._proxy_to_api("POST")
            except Exception as e:
                logger.error(f"PROXY: Ошибка при проксировании POST запроса: {e}")
                # В случае ошибки возвращаем базовый успешный ответ
                self._send_response(200, json.dumps({"success": True}))
        
        def do_OPTIONS(self):
            logger.info(f"PROXY: OPTIONS запрос: {self.path}")
            self.send_response(200)
            self.send_header('Access-Control-Allow-Origin', '*')
            self.send_header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
            self.send_header('Access-Control-Allow-Headers', 'Content-Type')
            self.end_headers()
        
        def _proxy_to_api(self, method):
            """Проксирует запрос к API серверу"""
            url = f"http://localhost:{API_PORT}{self.path}"
            logger.info(f"PROXY: Проксирование запроса к API: {url}")
            
            req = urllib.request.Request(url, method=method)
            
            # Копирование заголовков
            for header, value in self.headers.items():
                if header.lower() not in ["host", "content-length"]:
                    req.add_header(header, value)
            
            # Для POST-запросов копируем тело
            if method == "POST":
                content_length = int(self.headers.get('Content-Length', 0))
                body = self.rfile.read(content_length)
                req.data = body
            
            # Выполняем запрос к API серверу
            with urllib.request.urlopen(req) as response:
                # Отправляем ответ клиенту
                self.send_response(response.status)
                
                # Копируем заголовки ответа
                for header, value in response.getheaders():
                    if header.lower() != "transfer-encoding":
                        self.send_header(header, value)
                
                # Добавляем CORS заголовки
                self.send_header('Access-Control-Allow-Origin', '*')
                self.end_headers()
                
                # Копируем тело ответа
                self.wfile.write(response.read())
        
        def _send_response(self, status_code, data):
            """Отправляет ответ с указанным статусом и данными"""
            self.send_response(status_code)
            self.send_header('Content-Type', 'application/json')
            self.send_header('Access-Control-Allow-Origin', '*')
            self.send_header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
            self.send_header('Access-Control-Allow-Headers', 'Content-Type')
            self.end_headers()
            
            if isinstance(data, str):
                self.wfile.write(data.encode('utf-8'))
            else:
                self.wfile.write(data)
        
        def log_message(self, format, *args):
            """Перенаправляем логи сервера в наш логгер"""
            logger.debug(f"PROXY: {self.address_string()} - {format % args}")
    
    # Запускаем прокси-сервер
    try:
        # Пытаемся создать HTTP сервер на стандартном порту PROXY_PORT
        try:
            server = socketserver.TCPServer(("", PROXY_PORT), SimpleProxyHandler)
            logger.info(f"Встроенный прокси-сервер успешно запущен на порту {PROXY_PORT}")
            server.serve_forever()
        except OSError as e:
            # Если порт занят, пробуем порт PROXY_PORT+1
            alt_port = PROXY_PORT + 1
            logger.warning(f"Не удалось запустить прокси на порту {PROXY_PORT}, пробуем порт {alt_port}")
            try:
                server = socketserver.TCPServer(("", alt_port), SimpleProxyHandler)
                logger.info(f"Встроенный прокси-сервер успешно запущен на порту {alt_port}")
                # Обновляем переменную окружения для UI
                os.environ["NEXT_PUBLIC_DESIGNER_API_URL"] = f"http://localhost:{alt_port}"
                os.environ["AGENT_SERVER_URL"] = f"http://localhost:{alt_port}"
                server.serve_forever()
            except Exception as inner_e:
                logger.error(f"Не удалось запустить прокси-сервер даже на альтернативном порту: {inner_e}")
                # Если и это не получилось, пробуем на порту 0 (любой свободный)
                try:
                    server = socketserver.TCPServer(("", 0), SimpleProxyHandler)
                    _, dynamic_port = server.server_address
                    logger.info(f"Встроенный прокси-сервер успешно запущен на динамическом порту {dynamic_port}")
                    # Обновляем переменную окружения для UI
                    os.environ["NEXT_PUBLIC_DESIGNER_API_URL"] = f"http://localhost:{dynamic_port}"
                    os.environ["AGENT_SERVER_URL"] = f"http://localhost:{dynamic_port}"
                    server.serve_forever()
                except Exception as last_e:
                    logger.error(f"Все попытки запустить прокси-сервер не удались: {last_e}")
                    # Сдаемся, нет смысла продолжать
                    return
    except Exception as e:
        logger.error(f"Критическая ошибка в прокси-сервере: {e}")

def main():
    processes = []
    try:
        # Проверяем существование файлов
        if not API_BINARY.exists():
            logger.error(f"API binary не найден: {API_BINARY}")
            return 1
        
        if not PLAYGROUND_DIR.exists():
            logger.error(f"Playground директория не найдена: {PLAYGROUND_DIR}")
            return 1
        
        # Запуск скрипта для создания временных файлов в /tmp
        tmp_files_script = Path(__file__).parent / "create_tmp_agents.sh"
        if tmp_files_script.exists():
            logger.info(f"Запуск скрипта создания временных файлов: {tmp_files_script}")
            try:
                os.chmod(tmp_files_script, 0o755)  # Даем права на выполнение
                subprocess.run(["bash", str(tmp_files_script)])
                logger.info("Скрипт создания временных файлов успешно выполнен")
            except Exception as e:
                logger.error(f"Ошибка при запуске скрипта создания временных файлов: {e}")
        else:
            logger.warning(f"Скрипт {tmp_files_script} не найден")
        
        # Создаем директории и устанавливаем права
        ensure_directory_permissions(AGENTS_DIR)
        ensure_directory_permissions(BACKUP_DIR)
        
        # Проверяем и создаем property.json
        check_and_create_property_json()
        
        # Проверяем и обновляем существующий property.json, если он не содержит predefined_graphs
        update_property_json()
        
        # Проверяем и создаем файлы агентов
        check_and_create_agent_files()
        
        # Проверка файлов перед запуском
        check_files()
        
        # Запускаем API сервер
        logger.info("Запуск TEN-Agent API сервера на порту 8080...")
        api_process = subprocess.Popen([str(API_BINARY)])
        processes.append(api_process)
        
        # Тестируем API
        test_thread = threading.Thread(target=test_api)
        test_thread.daemon = True
        test_thread.start()
        
        # Запускаем прокси-сервер
        proxy_script = Path(__file__).parent / "proxy_server.py"
        logger.info(f"Проверка наличия прокси-сервера по пути: {proxy_script}")

        # Запуск автономного прокси-сервера через скрипт
        autonomous_proxy_script = Path(__file__).parent / "start_proxy.sh"
        try:
            if autonomous_proxy_script.exists():
                logger.info(f"Запуск автономного прокси-сервера через: {autonomous_proxy_script}")
                os.chmod(autonomous_proxy_script, 0o755)  # Даем права на выполнение
                proxy_process = subprocess.Popen(["bash", str(autonomous_proxy_script)])
                processes.append(proxy_process)
                logger.info("Автономный прокси-сервер запущен")
            else:
                logger.warning(f"Скрипт {autonomous_proxy_script} не найден")
        except Exception as e:
            logger.error(f"Ошибка при запуске автономного прокси-сервера: {e}")

        # Запускаем встроенный прокси-сервер как резервный вариант
        # Проверяем наличие файла разными способами для диагностики
        if proxy_script.exists():
            logger.info(f"Найден файл прокси-сервера: {proxy_script}")
            proxy_process = subprocess.Popen([sys.executable, str(proxy_script)], env=dict(os.environ, PROXY_PORT=str(PROXY_PORT)))
            processes.append(proxy_process)
        else:
            # Пробуем искать файл в текущем каталоге
            alt_path = Path("./proxy_server.py")
            logger.info(f"Поиск альтернативного пути: {alt_path}")
            if alt_path.exists():
                logger.info(f"Найден файл прокси-сервера по альтернативному пути: {alt_path}")
                proxy_process = subprocess.Popen([sys.executable, str(alt_path)], env=dict(os.environ, PROXY_PORT=str(PROXY_PORT)))
                processes.append(proxy_process)
            else:
                # Пробуем запустить напрямую через Python
                try:
                    logger.info("Попытка запуска proxy_server.py через subprocess...")
                    proxy_process = subprocess.Popen([sys.executable, "-m", "proxy_server"], env=dict(os.environ, PROXY_PORT=str(PROXY_PORT)))
                    processes.append(proxy_process)
                    logger.info("Прокси-сервер запущен через модуль")
                except Exception as e:
                    logger.warning(f"Не удалось запустить прокси-сервер через модуль: {e}")
                    
                    # Вместо вложенного try-except используем новый блок
                    logger.info("Создание встроенного прокси-сервера...")
                    
                    try:
                        # Запускаем прокси-сервер в отдельном потоке - обязательный запуск
                        proxy_thread = threading.Thread(target=run_simple_proxy)
                        proxy_thread.daemon = True
                        proxy_thread.start()
                        logger.info(f"Встроенный прокси-сервер запущен на порту {PROXY_PORT}")
                    except Exception as e:
                        logger.error(f"Серьезная ошибка при запуске встроенного прокси-сервера: {e}")
                        # Даже если встроенный прокси не запустился, не сдаемся - используем директные URL
        
        # Настраиваем переменные окружения для Playground UI
        os.environ["PORT"] = "7860"
        os.environ["AGENT_SERVER_URL"] = f"http://localhost:{PROXY_PORT}"  # Используем прокси вместо прямого подключения
        os.environ["NEXT_PUBLIC_EDIT_GRAPH_MODE"] = "true"  # Включаем расширенный режим редактирования
        os.environ["NEXT_PUBLIC_DISABLE_CAMERA"] = "true"  # Отключаем запрос на использование камеры
        
        # Важные переменные для отключения запросов к дизайнеру
        os.environ["NEXT_PUBLIC_DEV_MODE"] = "false"
        os.environ["NEXT_PUBLIC_API_BASE_URL"] = "/api/agents"
        os.environ["NEXT_PUBLIC_DESIGNER_API_URL"] = f"http://localhost:{PROXY_PORT}"  # Используем прокси для запросов дизайнера
        
        # Запускаем Playground UI
        playground_process = subprocess.Popen(
            ["pnpm", "dev"],
            cwd=str(PLAYGROUND_DIR),
            env=os.environ
        )
        processes.append(playground_process)
        
        # Ожидаем завершения процессов
        for proc in processes:
            proc.wait()
        
    except KeyboardInterrupt:
        logger.info("Завершение работы...")
    except Exception as e:
        logger.error(f"Ошибка: {e}")
    finally:
        # Завершение процессов
        for proc in processes:
            if proc and proc.poll() is None:
                proc.terminate()
                try:
                    proc.wait(timeout=5)
                except subprocess.TimeoutExpired:
                    proc.kill()
    
    return 0

if __name__ == "__main__":
    # Корректная обработка сигналов
    signal.signal(signal.SIGINT, lambda sig, frame: sys.exit(0))
    signal.signal(signal.SIGTERM, lambda sig, frame: sys.exit(0))
    
    sys.exit(main())