Новая версия fallback.py без изменения прав доступа для работы на Hugging Face Space

fallback.py

@@ -1,338 +1,585 @@
 #!/usr/bin/env python3
 import os
-import json
-import subprocess
 import sys
+import json
 import time
 import shutil
+import signal
+import logging
+import subprocess
 from pathlib import Path
+import tempfile
 import threading
-import urllib.request
-import urllib.error
 
-def create_user_directory():
-    """Создает отдельную директорию для пользовательских файлов"""
-    print("Creating user directory...")
-    
-    # Создаем пользовательскую директорию
-    user_dir = Path("/tmp/ten_user")
-    user_dir.mkdir(exist_ok=True, parents=True)
-    
-    # Создаем структуру директорий
-    agents_dir = user_dir / "agents"
-    agents_dir.mkdir(exist_ok=True, parents=True)
-    server_bin_dir = user_dir / "server" / "bin"
-    server_bin_dir.mkdir(exist_ok=True, parents=True)
-    
-    # Создаем директорию для логов
-    logs_dir = user_dir / "logs"
-    logs_dir.mkdir(exist_ok=True, parents=True)
-    
-    # Создаем директорию для кэша Go
-    go_cache_dir = Path("/tmp/go-cache")
-    go_cache_dir.mkdir(exist_ok=True, parents=True)
-    
-    # Создаем директорию для RAG данных
-    rag_dir = user_dir / "rag_data"
-    rag_dir.mkdir(exist_ok=True, parents=True)
-    
-    print(f"Created directory structure at {user_dir}")
-    return user_dir, agents_dir, server_bin_dir, logs_dir, go_cache_dir, rag_dir
+# Настройка логирования
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[logging.StreamHandler()]
+)
+logger = logging.getLogger("TEN-Agent")
 
-def create_basic_files(agents_dir):
-    """Создает базовые файлы конфигурации для TEN-Agent"""
-    print("Creating basic configuration files...")
-    
-    # Создаем manifest.json
-    manifest = {
-        "_ten": {"version": "0.0.1"},
-        "name": "default",
-        "agents": [
-            {
-                "name": "voice_agent",
-                "description": "A simple voice agent",
-                "type": "voice"
-            },
-            {
-                "name": "chat_agent",
-                "description": "A text chat agent",
-                "type": "chat"
-            }
-        ]
-    }
-    
-    with open(agents_dir / "manifest.json", "w") as f:
-        json.dump(manifest, f, indent=2)
-    
-    # Создаем property.json
-    property_data = {
-        "name": "TEN Agent Example",
-        "version": "0.0.1",
-        "extensions": ["openai_chatgpt"],
-        "description": "A basic voice agent with OpenAI",
-        "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 open(agents_dir / "property.json", "w") as f:
-        json.dump(property_data, f, indent=2)
-    
-    # Создаем voice_agent.json
-    voice_agent = {
-        "_ten": {"version": "0.0.1"},
-        "nodes": [
-            {
-                "id": "start",
-                "type": "start",
-                "data": {"x": 100, "y": 100}
-            },
-            {
-                "id": "openai_chatgpt",
-                "type": "openai_chatgpt",
-                "data": {
-                    "x": 300,
-                    "y": 200,
-                    "properties": {
-                        "model": "gpt-3.5-turbo",
-                        "temperature": 0.7,
-                        "system_prompt": "You are a helpful assistant."
-                    }
-                }
-            },
-            {
-                "id": "end",
-                "type": "end",
-                "data": {"x": 500, "y": 100}
-            }
-        ],
-        "edges": [
-            {
-                "id": "start_to_chatgpt",
-                "source": "start",
-                "target": "openai_chatgpt"
-            },
-            {
-                "id": "chatgpt_to_end",
-                "source": "openai_chatgpt",
-                "target": "end"
-            }
-        ],
-        "groups": [],
-        "templates": [],
-        "root": "start"
-    }
-    
-    with open(agents_dir / "voice_agent.json", "w") as f:
-        json.dump(voice_agent, f, indent=2)
-    
-    # Создаем chat_agent.json (аналогичный voice_agent.json)
-    chat_agent = dict(voice_agent)
-    chat_agent["nodes"][1]["data"]["properties"]["system_prompt"] = "You are a helpful chat assistant."
-    
-    with open(agents_dir / "chat_agent.json", "w") as f:
-        json.dump(chat_agent, f, indent=2)
-    
-    print("Basic configuration files created successfully.")
+# Пути к директориям
+TMP_DIR = Path("/tmp/ten_user")
+LOG_DIR = TMP_DIR / "logs"
+AGENTS_DIR = TMP_DIR / "agents"
+RAG_DIR = TMP_DIR / "rag_data"
 
-def check_file_permissions(filepath):
-    """Проверяет и выводит права доступа для файла"""
+def setup_environment():
+    """Настройка базового окружения"""
+    logger.info("Current directory: %s", os.getcwd())
+    logger.info("Current user: %s", os.environ.get('USER', 'unknown'))
+    
+    # Информация об окружении
+    logger.info("HOME: %s", os.environ.get('HOME', 'Not set'))
+    logger.info("PATH: %s", os.environ.get('PATH', 'Not set'))
+    
+    # Проверка прав доступа во временной директории
+    logger.info("Checking permissions for %s", "/tmp")
     try:
-        print(f"Checking permissions for {filepath}")
-        if not Path(filepath).exists():
-            print(f"  - File does not exist!")
-            return
+        result = subprocess.run(["ls", "-la", "/tmp"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        logger.info("  - %s", result.stdout.decode('utf-8').strip())
         
-        # Получаем права доступа и информацию о файле
-        result = subprocess.run(["ls", "-la", filepath], capture_output=True, text=True)
-        if result.returncode == 0:
-            print(f"  - {result.stdout.strip()}")
-        else:
-            print(f"  - Error: {result.stderr.strip()}")
-            
-        # Проверяем, можем ли писать в файл
+        # Проверка возможности записи
+        test_file = "/tmp/ten_test_write.txt"
+        can_write = False
         try:
-            with open(filepath, "a") as f:
-                pass
-            print("  - Can write: Yes")
-        except PermissionError:
-            print("  - Can write: No (Permission denied)")
+            with open(test_file, 'w') as f:
+                f.write("Test write")
+            can_write = True
+            logger.info("  - Can write: Yes")
+            os.remove(test_file)
         except Exception as e:
-            print(f"  - Can write: No ({e})")
+            logger.info("  - Can write: No (%s)", str(e))
+            
+        if not can_write:
+            logger.error("Cannot write to /tmp. This is required for operation.")
+            sys.exit(1)
     except Exception as e:
-        print(f"Error checking permissions: {e}")
+        logger.error("Error checking permissions: %s", str(e))
 
-def test_api_connection(max_attempts=5):
-    """Проверяет, доступен ли API сервер"""
-    print("\nTesting API server connection...")
-    for attempt in range(max_attempts):
-        try:
-            with urllib.request.urlopen("http://localhost:8080/health") as response:
-                if response.status == 200:
-                    print(f"✅ API server is working! Response: {response.read().decode()}")
-                    return True
-                else:
-                    print(f"❌ API server responded with status {response.status}")
-        except Exception as e:
-            print(f"❌ Attempt {attempt+1}/{max_attempts}: API server connection failed: {e}")
-        
-        if attempt < max_attempts - 1:
-            print(f"Waiting 2 seconds before next attempt...")
-            time.sleep(2)
+def create_directory_structure():
+    """Создание необходимой структуры директорий"""
+    logger.info("Creating user directory...")
     
-    print("Could not connect to API server after multiple attempts")
-    return False
+    # Создание основной директории
+    TMP_DIR.mkdir(exist_ok=True)
+    logger.info(f"Created directory structure at {TMP_DIR}")
+    
+    # Создание поддиректорий
+    AGENTS_DIR.mkdir(exist_ok=True)
+    RAG_DIR.mkdir(exist_ok=True)
+    LOG_DIR.mkdir(exist_ok=True)
+    logger.info(f"Created log directory at {LOG_DIR}")
 
-def main():
-    try:
-        print(f"Starting TEN-Agent in fallback mode...")
-        print(f"Current directory: {os.getcwd()}")
-        
-        # Выводим информацию о среде
-        user = os.environ.get('USER', 'unknown')
-        print(f"Current user: {user}")
-        print(f"HOME: {os.environ.get('HOME', 'unset')}")
-        print(f"PATH: {os.environ.get('PATH', 'unset')}")
-        
-        # Проверяем наличие /tmp и права на него
-        check_file_permissions("/tmp")
-        
-        # Создаем пользовательские директории
-        user_dir, agents_dir, server_bin_dir, logs_dir, go_cache_dir, rag_dir = create_user_directory()
-        
-        # Создаем пустой файл в директории логов, чтобы точно создать директорию
-        (logs_dir / "server.log").touch()
-        print(f"Created log directory at {logs_dir}")
-        
-        # Создаем базовые конфи��урационные файлы
-        create_basic_files(agents_dir)
-        
-        # Установка переменных среды для Playground
-        os.environ["PORT"] = "7860"  # HuggingFace использует порт 7860
-        os.environ["AGENT_SERVER_URL"] = "http://localhost:8080"
-        os.environ["NEXT_PUBLIC_EDIT_GRAPH_MODE"] = "true"
-        os.environ["NEXT_PUBLIC_DISABLE_CAMERA"] = "true"
-        os.environ["TEN_AGENT_DIR"] = str(agents_dir)
-        
-        # Запускаем API сервер с использованием нашей обертки
-        print(f"Starting API server with agents directory: {agents_dir}")
-        api_env = os.environ.copy()
-        api_env["TEN_AGENT_DIR"] = str(agents_dir)
-        
-        # Проверяем наличие API wrapper
-        wrapper_path = Path("/app/api_wrapper.py")
-        if not wrapper_path.exists():
-            print(f"Error: API wrapper not found at {wrapper_path}")
-            sys.exit(1)
-            
-        # Убедимся, что у скрипта есть права на исполнение
-        wrapper_path.chmod(0o755)
-        
-        # Запускаем API обертку
-        print(f"Using Python API wrapper instead of original server")
-        api_process = subprocess.Popen(
-            ["python3", str(wrapper_path)],
-            env=api_env,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE
-        )
+def create_basic_config():
+    """Создание базовых конфигурационных файлов"""
+    logger.info("Creating basic configuration files...")
+    
+    # Создание property.json
+    property_path = AGENTS_DIR / "property.json"
+    if not property_path.exists():
+        property_data = {
+            "_ten": {
+                "version": "0.0.1"
+            },
+            "name": "TEN Agent Example",
+            "version": "0.0.1",
+            "extensions": ["openai_chatgpt"],
+            "description": "A basic voice agent with OpenAI",
+            "graphs": [
+                {
+                    "id": "voice_agent",
+                    "name": "Voice Agent",
+                    "description": "Basic voice agent with OpenAI",
+                    "file": "examples/voice_agent.json"
+                },
+                {
+                    "id": "chat_agent",
+                    "name": "Chat Agent",
+                    "description": "Simple chat agent",
+                    "file": "examples/chat_agent.json"
+                }
+            ]
+        }
         
-        # Даем серверу время для запуска
-        time.sleep(2)
+        with open(property_path, 'w') as f:
+            json.dump(property_data, f, indent=2)
+    
+    # Создание директории examples
+    examples_dir = AGENTS_DIR / "examples"
+    examples_dir.mkdir(exist_ok=True)
+    
+    # Создание voice_agent.json
+    voice_agent_path = examples_dir / "voice_agent.json"
+    if not voice_agent_path.exists():
+        voice_data = {
+            "_ten": {
+                "version": "0.0.1"
+            },
+            "nodes": [
+                {
+                    "id": "start",
+                    "type": "start",
+                    "data": {
+                        "x": 100,
+                        "y": 100
+                    }
+                },
+                {
+                    "id": "openai_chatgpt",
+                    "type": "openai_chatgpt",
+                    "data": {
+                        "x": 300,
+                        "y": 200,
+                        "properties": {
+                            "model": "gpt-3.5-turbo",
+                            "temperature": 0.7,
+                            "system_prompt": "Вы полезный голосовой помощник."
+                        }
+                    }
+                },
+                {
+                    "id": "end",
+                    "type": "end",
+                    "data": {
+                        "x": 500,
+                        "y": 100
+                    }
+                }
+            ],
+            "edges": [
+                {
+                    "id": "start_to_chatgpt",
+                    "source": "start",
+                    "target": "openai_chatgpt"
+                },
+                {
+                    "id": "chatgpt_to_end",
+                    "source": "openai_chatgpt",
+                    "target": "end"
+                }
+            ],
+            "groups": [],
+            "templates": [],
+            "root": "start"
+        }
         
-        # Проверяем, запустился ли сервер
-        if api_process.poll() is not None:
-            print("API server failed to start!")
-            stdout, stderr = api_process.communicate()
-            print(f"STDOUT: {stdout.decode() if stdout else 'No output'}")
-            print(f"STDERR: {stderr.decode() if stderr else 'No error output'}")
-            sys.exit(1)
+        with open(voice_agent_path, 'w') as f:
+            json.dump(voice_data, f, indent=2)
+    
+    # Создание chat_agent.json
+    chat_agent_path = examples_dir / "chat_agent.json"
+    if not chat_agent_path.exists():
+        chat_data = {
+            "_ten": {
+                "version": "0.0.1"
+            },
+            "nodes": [
+                {
+                    "id": "start",
+                    "type": "start",
+                    "data": {
+                        "x": 100,
+                        "y": 100
+                    }
+                },
+                {
+                    "id": "openai_chatgpt",
+                    "type": "openai_chatgpt",
+                    "data": {
+                        "x": 300,
+                        "y": 200,
+                        "properties": {
+                            "model": "gpt-3.5-turbo",
+                            "temperature": 0.7,
+                            "system_prompt": "Вы полезный чат-бот."
+                        }
+                    }
+                },
+                {
+                    "id": "end",
+                    "type": "end",
+                    "data": {
+                        "x": 500,
+                        "y": 100
+                    }
+                }
+            ],
+            "edges": [
+                {
+                    "id": "start_to_chatgpt",
+                    "source": "start",
+                    "target": "openai_chatgpt"
+                },
+                {
+                    "id": "chatgpt_to_end",
+                    "source": "openai_chatgpt",
+                    "target": "end"
+                }
+            ],
+            "groups": [],
+            "templates": [],
+            "root": "start"
+        }
         
-        # Проверяем доступность API
-        print("Testing API server availability...")
-        api_success = test_api_connection()
+        with open(chat_agent_path, 'w') as f:
+            json.dump(chat_data, f, indent=2)
+    
+    # Создание manifest.json
+    manifest_path = AGENTS_DIR / "manifest.json"
+    if not manifest_path.exists():
+        manifest_data = {
+            "_ten": {
+                "version": "0.0.1"
+            },
+            "name": "default",
+            "agents": [
+                {
+                    "name": "voice_agent",
+                    "description": "A simple voice agent",
+                    "type": "voice"
+                },
+                {
+                    "name": "chat_agent",
+                    "description": "A text chat agent",
+                    "type": "chat"
+                }
+            ]
+        }
         
-        if not api_success:
-            print("WARNING: API server may not be working correctly!")
-            
-        # Запускаем playground
-        print("Starting Playground UI...")
-        playground_path = Path("/app/playground")
-        if not playground_path.exists():
-            print(f"Error: Playground directory not found at {playground_path}")
-            sys.exit(1)
+        with open(manifest_path, 'w') as f:
+            json.dump(manifest_data, f, indent=2)
+    
+    logger.info("Basic configuration files created successfully.")
+
+def run_api_server():
+    """Запуск API сервера"""
+    # Конфигурирование переменных среды
+    os.environ["AGENT_SERVER_DIRECTORY"] = str(AGENTS_DIR)
+    
+    logger.info(f"Starting API server with agents directory: {AGENTS_DIR}")
+    
+    # Запуск API сервера напрямую из директории server
+    api_binary = Path("/app/server/bin/api")
+    if not api_binary.exists():
+        logger.error(f"API binary not found at {api_binary}")
+        raise FileNotFoundError(f"API binary not found at {api_binary}")
+    
+    cmd = [str(api_binary)]
+    logger.info(f"Running command: {' '.join(cmd)}")
+    
+    # Запуск процесса сервера
+    api_process = subprocess.Popen(
+        cmd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        bufsize=1,
+    )
+    
+    # Логирование вывода процесса
+    def log_output(stream, prefix):
+        for line in stream:
+            logger.info(f"{prefix}: {line.strip()}")
+    
+    threading.Thread(target=log_output, args=(api_process.stdout, "API"), daemon=True).start()
+    threading.Thread(target=log_output, args=(api_process.stderr, "API ERROR"), daemon=True).start()
+    
+    # Проверка, что процесс запустился
+    time.sleep(2)
+    if api_process.poll() is not None:
+        logger.error(f"API server failed to start with exit code {api_process.returncode}")
+        raise RuntimeError(f"API server failed to start with exit code {api_process.returncode}")
+    
+    logger.info("API server started successfully")
+    return api_process
+
+def run_proxy_server():
+    """Запуск прокси-сервера для обработки запросов TEN-Agent Designer API"""
+    # Код для запуска прокси-сервера
+    logger.info("Starting proxy server for Designer API requests")
+    
+    import http.server
+    import socketserver
+    import urllib.request
+    import urllib.error
+    import json
+    
+    class ProxyHTTPRequestHandler(http.server.SimpleHTTPRequestHandler):
+        def do_POST(self):
+            logger.info(f"Received POST request: {self.path}")
             
-        playground_process = subprocess.Popen(
-            "cd /app/playground && pnpm dev",
-            env=os.environ,
-            shell=True,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE
-        )
+            # Перенаправляем запрос /api/dev/v1/packages/reload на /graphs
+            if self.path.startswith('/api/dev/v1/packages/reload') or self.path.startswith('/api/designer/v1/packages/reload'):
+                try:
+                    logger.info("Redirecting to /graphs")
+                    
+                    try:
+                        with urllib.request.urlopen("http://localhost:8080/graphs") as response:
+                            data = response.read().decode('utf-8')
+                            
+                            # Если сервер вернул пустой ответ или ошибку, создаем свой собственный ответ
+                            if not data or "Invalid format" in data:
+                                logger.info("Server returned error or empty response, creating custom response")
+                                # Создаем хардкодный список графов из property.json
+                                property_path = AGENTS_DIR / "property.json"
+                                if property_path.exists():
+                                    try:
+                                        with open(property_path, 'r') as f:
+                                            property_data = json.load(f)
+                                            graphs = property_data.get("graphs", [])
+                                    except Exception as e:
+                                        logger.error(f"Error reading property.json: {e}")
+                                        graphs = []
+                                else:
+                                    graphs = []
+                                
+                                # Добавляем обязательные поля для каждого графа
+                                for graph in graphs:
+                                    if "id" not in graph:
+                                        graph["id"] = graph.get("name", "").lower().replace(" ", "_")
+                            else:
+                                try:
+                                    # Пытаемся разобрать JSON из ответа
+                                    graphs = json.loads(data)
+                                except json.JSONDecodeError:
+                                    logger.error(f"Error parsing JSON from server response: {data}")
+                                    graphs = []
+                            
+                            # Форматируем ответ в нужном формате для фронтенда
+                            formatted_response = {
+                                "data": graphs,
+                                "status": 200,
+                                "message": "Success"
+                            }
+                            
+                            response_data = json.dumps(formatted_response).encode('utf-8')
+                            
+                            # Отправляем ответ
+                            self.send_response(200)
+                            self.send_header('Content-Type', 'application/json')
+                            self.send_header('Content-Length', len(response_data))
+                            self.send_header('Access-Control-Allow-Origin', '*')
+                            self.end_headers()
+                            self.wfile.write(response_data)
+                            logger.info(f"Sent response: {response_data.decode('utf-8')}")
+                    except urllib.error.URLError as e:
+                        logger.error(f"Error when redirecting: {e}")
+                        # В случае ошибки, отправляем хардкодный ответ
+                        property_path = AGENTS_DIR / "property.json"
+                        if property_path.exists():
+                            try:
+                                with open(property_path, 'r') as f:
+                                    property_data = json.load(f)
+                                    graphs = property_data.get("graphs", [])
+                            except Exception as e:
+                                logger.error(f"Error reading property.json: {e}")
+                                graphs = []
+                        else:
+                            graphs = []
+                        
+                        # Добавляем обязательные поля для каждого графа
+                        for graph in graphs:
+                            if "id" not in graph:
+                                graph["id"] = graph.get("name", "").lower().replace(" ", "_")
+                        
+                        formatted_response = {
+                            "data": graphs,
+                            "status": 200,
+                            "message": "Success"
+                        }
+                        
+                        response_data = json.dumps(formatted_response).encode('utf-8')
+                        
+                        self.send_response(200)
+                        self.send_header('Content-Type', 'application/json')
+                        self.send_header('Content-Length', len(response_data))
+                        self.send_header('Access-Control-Allow-Origin', '*')
+                        self.end_headers()
+                        self.wfile.write(response_data)
+                        logger.info(f"Sent hardcoded response: {response_data.decode('utf-8')}")
+                except Exception as e:
+                    logger.error(f"Unexpected error: {e}")
+                    self.send_error(500, f"Internal Server Error: {str(e)}")
+            else:
+                self.send_error(404, "Not Found")
+                
+        def do_OPTIONS(self):
+            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()
         
-        # Даем UI время для запуска
-        time.sleep(5)
-        
-        # Проверяем, запустился ли UI
-        if playground_process.poll() is not None:
-            print("Playground UI failed to start!")
-            stdout, stderr = playground_process.communicate()
-            print(f"STDOUT: {stdout.decode() if stdout else 'No output'}")
-            print(f"STDERR: {stderr.decode() if stderr else 'No error output'}")
+        def do_GET(self):
+            logger.info(f"Received GET request: {self.path}")
             
-            # Останавливаем API сервер
-            api_process.terminate()
-            sys.exit(1)
-        
-        print("TEN-Agent started successfully in fallback mode.")
-        print("Playground UI is available at http://localhost:7860")
+            # Перенаправляем запрос /api/designer/v1/addons/extensions
+            if self.path.startswith('/api/designer/v1/addons/extensions'):
+                # Отправляем хардкодный ответ со списком расширений
+                extensions = [
+                    {
+                        "id": "openai_chatgpt",
+                        "name": "OpenAI ChatGPT",
+                        "version": "0.0.1",
+                        "description": "Integration with OpenAI ChatGPT API",
+                        "nodes": [
+                            {
+                                "id": "openai_chatgpt",
+                                "name": "OpenAI ChatGPT",
+                                "category": "AI",
+                                "description": "Sends message to OpenAI ChatGPT API"
+                            }
+                        ]
+                    }
+                ]
+                
+                formatted_response = {
+                    "data": extensions,
+                    "status": 200,
+                    "message": "Success"
+                }
+                
+                response_data = json.dumps(formatted_response).encode('utf-8')
+                
+                self.send_response(200)
+                self.send_header('Content-Type', 'application/json')
+                self.send_header('Content-Length', len(response_data))
+                self.send_header('Access-Control-Allow-Origin', '*')
+                self.end_headers()
+                self.wfile.write(response_data)
+                logger.info(f"Sent response for extensions: {response_data.decode('utf-8')}")
+            else:
+                self.send_error(404, "Not Found")
+    
+    # Запуск HTTP сервера
+    port = 49483
+    httpd = socketserver.ThreadingTCPServer(("", port), ProxyHTTPRequestHandler)
+    logger.info(f"Proxy server started at port {port}")
+    
+    # Запуск в отдельном потоке
+    proxy_thread = threading.Thread(target=httpd.serve_forever)
+    proxy_thread.daemon = True
+    proxy_thread.start()
+    
+    return httpd
+
+def run_playground():
+    """Запуск Playground UI"""
+    logger.info("Starting Playground UI in development mode")
+    
+    # Настройка окружения для Playground
+    env = os.environ.copy()
+    env["PORT"] = "7860"
+    env["AGENT_SERVER_URL"] = "http://localhost:8080"
+    env["NEXT_PUBLIC_EDIT_GRAPH_MODE"] = "true"
+    env["NEXT_PUBLIC_DISABLE_CAMERA"] = "true"
+    
+    playground_dir = Path("/app/playground")
+    if not playground_dir.exists():
+        logger.error(f"Playground directory not found at {playground_dir}")
+        raise FileNotFoundError(f"Playground directory not found at {playground_dir}")
+    
+    cmd = ["pnpm", "dev"]
+    logger.info(f"Running command in {playground_dir}: {' '.join(cmd)}")
+    
+    # Запуск процесса Playground
+    playground_process = subprocess.Popen(
+        cmd,
+        cwd=str(playground_dir),
+        env=env,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        bufsize=1,
+    )
+    
+    # Логирование вывода процесса
+    def log_output(stream, prefix):
+        for line in stream:
+            logger.info(f"{prefix}: {line.strip()}")
+    
+    threading.Thread(target=log_output, args=(playground_process.stdout, "PLAYGROUND"), daemon=True).start()
+    threading.Thread(target=log_output, args=(playground_process.stderr, "PLAYGROUND ERROR"), daemon=True).start()
+    
+    # Проверка, что процесс запустился
+    time.sleep(3)
+    if playground_process.poll() is not None:
+        logger.error(f"Playground UI failed to start with exit code {playground_process.returncode}")
+        raise RuntimeError(f"Playground UI failed to start with exit code {playground_process.returncode}")
+    
+    logger.info("Playground UI started successfully")
+    return playground_process
+
+def main():
+    """Основная функция запуска"""
+    try:
+        # Настройка окружения
+        setup_environment()
         
-        # Следим за выводом процессов в реальном времени
-        def stream_output(process, name):
-            for line in iter(process.stdout.readline, b''):
-                print(f"[{name}] {line.decode().strip()}")
-            
-            # После завершения стандартного вывода, читаем stderr
-            for line in iter(process.stderr.readline, b''):
-                print(f"[{name} ERROR] {line.decode().strip()}")
+        # Создание структуры директорий
+        create_directory_structure()
         
-        api_thread = threading.Thread(target=stream_output, args=(api_process, "API"))
-        ui_thread = threading.Thread(target=stream_output, args=(playground_process, "UI"))
+        # Создание базовых конфигурационных файлов
+        create_basic_config()
         
-        api_thread.daemon = True
-        ui_thread.daemon = True
+        # Запуск сервисов
+        api_process = run_api_server()
+        proxy_server = run_proxy_server()
+        playground_process = run_playground()
         
-        api_thread.start()
-        ui_thread.start()
+        # Отслеживание статуса процессов
+        logger.info("All services started. Monitoring status...")
         
-        # Ожидаем завершения любого из процессов
-        while True:
-            if api_process.poll() is not None:
-                print("API server has stopped.")
-                playground_process.terminate()
-                break
+        try:
+            while True:
+                # Проверка статуса API сервера
+                if api_process.poll() is not None:
+                    logger.error(f"API server exited with code {api_process.returncode}")
+                    break
+                
+                # Проверка статуса Playground
+                if playground_process.poll() is not None:
+                    logger.error(f"Playground UI exited with code {playground_process.returncode}")
+                    break
+                
+                time.sleep(5)
+        except KeyboardInterrupt:
+            logger.info("Received interrupt signal")
+        finally:
+            # Остановка сервисов
+            logger.info("Stopping services...")
             
-            if playground_process.poll() is not None:
-                print("Playground UI has stopped.")
-                api_process.terminate()
-                break
+            try:
+                if api_process and api_process.poll() is None:
+                    api_process.terminate()
+                    api_process.wait(timeout=5)
+            except Exception as e:
+                logger.warning(f"Error stopping API server: {e}")
             
-            time.sleep(1)
-        
+            try:
+                if playground_process and playground_process.poll() is None:
+                    playground_process.terminate()
+                    playground_process.wait(timeout=5)
+            except Exception as e:
+                logger.warning(f"Error stopping Playground UI: {e}")
+            
+            try:
+                proxy_server.shutdown()
+            except Exception as e:
+                logger.warning(f"Error stopping proxy server: {e}")
+    
     except Exception as e:
-        print(f"Error: {e}")
-        import traceback
-        traceback.print_exc()
-        sys.exit(1)
+        logger.error(f"Error: {e}", exc_info=True)
+        return 1
+    
+    return 0
 
 if __name__ == "__main__":
-    main() 
+    # Настройка обработки сигналов
+    signal.signal(signal.SIGINT, lambda sig, frame: sys.exit(0))
+    signal.signal(signal.SIGTERM, lambda sig, frame: sys.exit(0))
+    
+    # Запуск основной функции
+    sys.exit(main())