Исправление прокси-сервера: добавлена обработка ошибок и хардкодные ответы

app.py

@@ -12,714 +12,409 @@ import http.server
 import socketserver
 import urllib.request
 import urllib.error
-import gradio as gr
 
-# Проверяем, запущены ли мы в HuggingFace Space
-IS_HF_SPACE = os.environ.get("SPACE_ID") is not None
-print(f"Running in HuggingFace Space: {IS_HF_SPACE}")
-
-# Конфигурация путей
-TMP_DIR = Path("/tmp/ten_user")
-AGENTS_DIR = TMP_DIR / "agents"
-LOGS_DIR = TMP_DIR / "logs"
-NEXTJS_PORT = int(os.environ.get("UI_PORT", 3000))
-API_PORT = int(os.environ.get("API_PORT", 8080))
-GRADIO_PORT = int(os.environ.get("GRADIO_PORT", 7860))
-
-# Адрес для подключения к UI в iframe
-if IS_HF_SPACE:
-    # В HuggingFace Space нужно использовать внутренний URL
-    UI_URL = f"https://{os.environ.get('SPACE_ID', 'unknown-space')}.hf.space/_next/iframe/3000"
-    INTERNAL_HOST = "0.0.0.0"
-else:
-    # В локальном окружении используем localhost
-    UI_URL = f"http://localhost:{NEXTJS_PORT}"
-    INTERNAL_HOST = "localhost"
-
-def create_directories():
-    """Создает необходимые директории"""
-    print("Создание директорий...")
-    
-    # Создаем только директории, без попытки создания файлов
-    TMP_DIR.mkdir(exist_ok=True, parents=True)
-    AGENTS_DIR.mkdir(exist_ok=True, parents=True)
-    LOGS_DIR.mkdir(exist_ok=True, parents=True)
-    
-    # Не создаем файл server.log, т.к. он вызывает ошибку прав доступа
-    # (LOGS_DIR / "server.log").touch()
-    
-    print(f"Директории созданы в {TMP_DIR}")
-    
-    # Выводим информацию о правах доступа для отладки
-    print(f"Права доступа для {TMP_DIR}: {os.stat(TMP_DIR).st_mode}")
-    if LOGS_DIR.exists():
-        print(f"Директория логов создана: {LOGS_DIR}")
-        print(f"Права доступа для {LOGS_DIR}: {os.stat(LOGS_DIR).st_mode}")
-    else:
-        print(f"Директория логов не создана: {LOGS_DIR}")
-    
-    # Пробуем записать лог в /tmp напрямую, где должны быть права на запись
-    try:
-        tmp_log_file = Path("/tmp/ten_server.log")
-        tmp_log_file.touch()
-        print(f"Создан файл лога в /tmp: {tmp_log_file}")
-    except Exception as e:
-        print(f"Не удалось создать файл лога в /tmp: {e}")
-        # Это не критическая ошибка, продолжаем работу
-
-def create_config_files():
-    """Создает базовые файлы конфигурации"""
-    print("Создание конфигурационных файлов...")
-    
-    # Используем директорию в /tmp напрямую, без вложенных директорий
-    config_dir = Path("/tmp")
-    property_file_path = config_dir / "property.json"
-    voice_agent_path = config_dir / "voice_agent.json"
-    chat_agent_path = config_dir / "chat_agent.json"
-    
-    # Создаем property.json с графами
-    property_data = {
-        "name": "TEN Agent Demo",
-        "version": "0.0.1",
-        "extensions": ["openai_chatgpt", "elevenlabs_tts", "deepgram_asr"],
-        "description": "TEN Agent on Hugging Face Space",
-        "graphs": [
-            {
-                "name": "Voice Agent",
-                "description": "Basic voice agent with OpenAI and ElevenLabs",
-                "file": "voice_agent.json"
-            },
-            {
-                "name": "Chat Agent",
-                "description": "Simple chat agent with OpenAI",
-                "file": "chat_agent.json"
-            }
-        ]
-    }
-    
-    try:
-        with open(property_file_path, "w") as f:
-            json.dump(property_data, f, indent=2)
-        print(f"Файл {property_file_path} создан успешно")
-    except Exception as e:
-        print(f"Ошибка при создании {property_file_path}: {e}")
-        return False
-    
-    # Создаем 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": "elevenlabs_tts",
-                "type": "elevenlabs_tts",
-                "data": {
-                    "x": 500,
-                    "y": 200,
-                    "properties": {
-                        "voice_id": "21m00Tcm4TlvDq8ikWAM"
-                    }
-                }
-            },
-            {
-                "id": "deepgram_asr",
-                "type": "deepgram_asr",
-                "data": {
-                    "x": 300,
-                    "y": 300,
-                    "properties": {
-                        "language": "ru"
-                    }
-                }
-            },
-            {
-                "id": "end",
-                "type": "end",
-                "data": {"x": 700, "y": 100}
-            }
-        ],
-        "edges": [
-            {"id": "start_to_chatgpt", "source": "start", "target": "openai_chatgpt"},
-            {"id": "chatgpt_to_tts", "source": "openai_chatgpt", "target": "elevenlabs_tts"},
-            {"id": "tts_to_end", "source": "elevenlabs_tts", "target": "end"},
-            {"id": "asr_to_chatgpt", "source": "deepgram_asr", "target": "openai_chatgpt"}
-        ],
-        "groups": [],
-        "templates": [],
-        "root": "start"
-    }
-    
-    try:
-        with open(voice_agent_path, "w") as f:
-            json.dump(voice_agent, f, indent=2)
-        print(f"Файл {voice_agent_path} создан успешно")
-    except Exception as e:
-        print(f"Ошибка при создании {voice_agent_path}: {e}")
-        return False
-    
-    # Создаем chat_agent.json (упрощенная версия)
-    chat_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 chat 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"
-    }
-    
-    try:
-        with open(chat_agent_path, "w") as f:
-            json.dump(chat_agent, f, indent=2)
-        print(f"Файл {chat_agent_path} создан успешно")
-    except Exception as e:
-        print(f"Ошибка при создании {chat_agent_path}: {e}")
-        return False
-    
-    # Обновляем глобальную переменную AGENTS_DIR для использования нового пути
-    global AGENTS_DIR
-    AGENTS_DIR = config_dir
-    print(f"Конфигурационные файлы созданы успешно в директории {config_dir}")
-    return True
-
-def start_api_server():
-    """Запускает API сервер"""
-    print("Запуск API сервера...")
-    
-    # Устанавливаем переменные окружения
-    api_env = os.environ.copy()
-    api_env["TEN_AGENT_DIR"] = str(AGENTS_DIR)
-    api_env["API_PORT"] = str(API_PORT)
-    
-    # Выводим информацию о директории с агентами для отладки
-    print(f"Директория с агентами: {AGENTS_DIR}")
-    print(f"Файлы в директории агентов:")
-    if AGENTS_DIR.exists():
-        for file in AGENTS_DIR.iterdir():
-            if file.name.endswith('.json'):
-                print(f"  - {file.name} ({os.path.getsize(file)}b)")
-    
-    # В HuggingFace Space нужны дополнительные настройки
-    if IS_HF_SPACE:
-        print("Configuring API server for HuggingFace Space environment...")
-        # Указываем серверу специально использовать API wrapper
-        api_env["USE_WRAPPER"] = "true"
-        # Отключаем логирование в файл
-        api_env["TEN_LOG_DISABLE_FILE"] = "true"
-        # Указываем путь для временных файлов
-        api_env["TMP_DIR"] = "/tmp"
-    
-    # Запускаем Python API wrapper
-    api_cmd = ["python", "api_wrapper.py"]
-    print(f"Running API command: {' '.join(api_cmd)}")
-    api_process = subprocess.Popen(
-        api_cmd,
-        env=api_env,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE
-    )
-    
-    # Ждем запуска сервера
-    time.sleep(2)
-    
-    # Проверяем, что процесс не упал
-    if api_process.poll() is not None:
-        stdout, stderr = api_process.communicate()
-        print(f"API сервер не запустился!")
-        print(f"STDOUT: {stdout.decode()}")
-        print(f"STDERR: {stderr.decode()}")
-        return None
+def check_and_create_property_json():
+    """Проверяет наличие property.json и создает его при необходимости"""
+    property_path = Path("/app/agents/property.json")
     
-    print(f"API server started and listening on port {API_PORT}")
-    
-    # Запускаем поток для вывода логов
-    def log_output(process, prefix):
-        for line in iter(process.stdout.readline, b''):
-            print(f"[{prefix}] {line.decode().strip()}")
-        for line in iter(process.stderr.readline, b''):
-            print(f"[{prefix} ERROR] {line.decode().strip()}")
-    
-    log_thread = threading.Thread(target=log_output, args=(api_process, "API"))
-    log_thread.daemon = True
-    log_thread.start()
-    
-    return api_process
-
-def start_playground():
-    """Запускает Playground UI через Next.js"""
-    print("Запуск Playground UI...")
-    
-    # Создаем директорию для Next.js в /tmp, где у нас есть права на запись
-    tmp_playground_dir = Path("/tmp/ten_playground")
-    if not tmp_playground_dir.exists():
-        print(f"Создаем временную директорию для Next.js: {tmp_playground_dir}")
-        tmp_playground_dir.mkdir(exist_ok=True, parents=True)
-    
-    # Копируем необходимые файлы из /app/playground в /tmp/ten_playground
-    print("Копируем файлы Next.js приложения во временную директорию...")
-    try:
-        os.system(f"cp -r /app/playground/app /tmp/ten_playground/")
-        os.system(f"cp -r /app/playground/public /tmp/ten_playground/")
-        os.system(f"cp /app/playground/package.json /tmp/ten_playground/")
-        os.system(f"cp /app/playground/next.config.mjs /tmp/ten_playground/")
-        os.system(f"cp /app/playground/tailwind.config.js /tmp/ten_playground/")
-        os.system(f"cp /app/playground/postcss.config.js /tmp/ten_playground/")
+    if not property_path.exists():
+        print(f"WARNING: {property_path} не найден, создаем файл...")
         
-        # Проверяем, что файлы скопировались
-        if not (tmp_playground_dir / "app").exists():
-            print("Не удалось скопировать файлы Next.js. Создаем простое приложение...")
-            create_simple_next_app(tmp_playground_dir)
-    except Exception as e:
-        print(f"Ошибка при копировании файлов: {e}")
-        print("Создаем простое приложение Next.js...")
-        create_simple_next_app(tmp_playground_dir)
-    
-    # Устанавливаем переменные окружения
-    ui_env = os.environ.copy()
-    ui_env["PORT"] = str(NEXTJS_PORT)
-    ui_env["AGENT_SERVER_URL"] = f"http://{INTERNAL_HOST}:{API_PORT}"
-    ui_env["NEXT_PUBLIC_EDIT_GRAPH_MODE"] = "true"
-    ui_env["NEXT_PUBLIC_DISABLE_CAMERA"] = "false"
-    
-    # В HuggingFace Space нужны дополнительные настройки
-    if IS_HF_SPACE:
-        print("Configuring for HuggingFace Space environment...")
-        ui_env["NEXT_PUBLIC_IS_HF_SPACE"] = "true"
-        # Отключаем строгие проверки CORS для работы в iframe
-        ui_env["NEXT_PUBLIC_DISABLE_CORS"] = "true"
-    
-    # Запускаем UI из временной директории, где у нас есть права на запись
-    ui_cmd = f"cd {tmp_playground_dir} && npx next dev"
-    print(f"Running UI command: {ui_cmd}")
-    ui_process = subprocess.Popen(
-        ui_cmd,
-        env=ui_env,
-        shell=True,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE
-    )
-    
-    # Ждем запуска UI
-    time.sleep(5)
-    
-    # Проверяем, что процесс не упал
-    if ui_process.poll() is not None:
-        stdout, stderr = ui_process.communicate()
-        print(f"Playground UI не запустился!")
-        print(f"STDOUT: {stdout.decode()}")
-        print(f"STDERR: {stderr.decode()}")
-        return None
-    
-    # Запускаем поток для вывода логов
-    def log_output(process, prefix):
-        for line in iter(process.stdout.readline, b''):
-            print(f"[{prefix}] {line.decode().strip()}")
-        for line in iter(process.stderr.readline, b''):
-            print(f"[{prefix} ERROR] {line.decode().strip()}")
-    
-    log_thread = threading.Thread(target=log_output, args=(ui_process, "UI"))
-    log_thread.daemon = True
-    log_thread.start()
-    
-    return ui_process
-
-def create_interface():
-    """Создает Gradio интерфейс для редиректа"""
-    with gr.Blocks() as demo:
-        gr.Markdown("# TEN Agent на Hugging Face Space")
-        gr.Markdown("## Управление и мониторинг")
+        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"
+                }
+            ]
+        }
         
-        # Статус серверов
-        status_md = gr.Markdown("### Статус: Инициализация...")
+        # Проверяем и создаем директории
+        property_path.parent.mkdir(parents=True, exist_ok=True)
         
-        with gr.Row():
-            col1, col2 = gr.Column(), gr.Column()
+        # Записываем файл
+        with open(property_path, 'w') as f:
+            json.dump(property_data, f, indent=2)
             
-            with col1:
-                # Информация об API сервере
-                gr.Markdown(f"""
-                ### API сервер
-                
-                API сервер работает по адресу: http://{INTERNAL_HOST}:{API_PORT}
-                
-                Доступные эндпоинты:
-                - `/graphs` - Список доступных графов
-                - `/health` - Статус API сервера
-                """)
-                
-                # Кнопка для проверки API
-                check_api_btn = gr.Button("Проверить API сервер")
-                api_result = gr.JSON(label="Результат запроса к API")
+        print(f"Файл {property_path} создан успешно")
+        
+    # Проверяем наличие _ten секции во всех JSON файлах
+    check_and_fix_ten_section()
+
+def check_and_fix_ten_section():
+    """Проверяет наличие _ten секции во всех JSON файлах и добавляет её если нужно"""
+    json_files = [
+        "/app/agents/voice_agent.json",
+        "/app/agents/chat_agent.json",
+        "/app/agents/manifest.json"
+    ]
+    
+    for file_path in json_files:
+        path = Path(file_path)
+        if path.exists():
+            try:
+                with open(path, 'r') as f:
+                    data = json.load(f)
                 
-                def check_api():
+                # Проверяем наличие _ten секции
+                if '_ten' not in data:
+                    print(f"Добавляем _ten секцию в {file_path}")
+                    data['_ten'] = {"version": "0.0.1"}
+                    
+                    # Сохраняем файл
+                    with open(path, 'w') as f:
+                        json.dump(data, f, indent=2)
+                        
+                    print(f"Файл {file_path} обновлен")
+            except Exception as e:
+                print(f"Ошибка при обработке файла {file_path}: {e}")
+
+class ProxyHTTPRequestHandler(http.server.SimpleHTTPRequestHandler):
+    def do_POST(self):
+        print(f"Получен запрос: {self.path}")
+        
+        # Перенаправляем запрос /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:
+                print("Перенаправление на /graphs")
+                with urllib.request.urlopen("http://localhost:8080/graphs") as response:
+                    data = response.read().decode('utf-8')
+                    
+                    # Если сервер вернул пустой ответ или ошибку, создаем свой собственный ответ
+                    if not data or "Invalid format" in data:
+                        print("Сервер вернул ошибку или пустой ответ, создаем свой ответ")
+                        # Создаем хардкодный список графов из property.json
+                        property_path = Path("/app/agents/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:
+                                print(f"Ошибка чтения property.json: {e}")
+                                graphs = []
+                        else:
+                            graphs = []
+                        
+                        # Добавляем обязательные поля для каждого графа
+                        for graph in graphs:
+                            graph["id"] = graph.get("name", "").lower().replace(" ", "_")
+                            if "file" in graph:
+                                graph["file"] = graph["file"]
+                    else:
+                        try:
+                            # Пытаемся разобрать JSON из ответа
+                            graphs = json.loads(data)
+                        except json.JSONDecodeError:
+                            print(f"Ошибка разбора JSON из ответа сервера: {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)
+                    print(f"Отправлен ответ: {response_data.decode('utf-8')}")
+            except urllib.error.URLError as e:
+                print(f"Ошибка при перенаправлении: {e}")
+                # В случае ошибки, отправляем хардкодный ответ
+                property_path = Path("/app/agents/property.json")
+                if property_path.exists():
                     try:
-                        import requests
-                        response = requests.get(f"http://{INTERNAL_HOST}:{API_PORT}/health")
-                        return response.json()
+                        with open(property_path, 'r') as f:
+                            property_data = json.load(f)
+                            graphs = property_data.get("graphs", [])
                     except Exception as e:
-                        return {"status": "error", "message": str(e)}
-                
-                check_api_btn.click(check_api, outputs=api_result)
-            
-            with col2:
-                # Информация о UI сервере
-                gr.Markdown(f"""
-                ### UI сервер
-                
-                UI сервер доступен по адресу: {UI_URL}
+                        print(f"Ошибка чтения property.json: {e}")
+                        graphs = []
+                else:
+                    graphs = []
                 
-                <a href="{UI_URL}" target="_blank" style="display: inline-block; padding: 10px 15px; background-color: #4CAF50; color: white; text-decoration: none; border-radius: 4px; margin: 10px 0;">Открыть UI в новой вкладке</a>
-                """)
+                # Добавляем обязательные поля для каждого графа
+                for graph in graphs:
+                    graph["id"] = graph.get("name", "").lower().replace(" ", "_")
+                    if "file" in graph:
+                        graph["file"] = graph["file"]
                 
-                # Функция для открытия UI в iframe
-                iframe_btn = gr.Button("Показать UI в iframe")
+                formatted_response = {
+                    "data": graphs,
+                    "status": 200,
+                    "message": "Success"
+                }
                 
-                def show_iframe():
-                    return f"""
-                    <div style="border: 1px solid #ccc; padding: 10px; border-radius: 5px;">
-                        <iframe src="{UI_URL}" width="100%" height="500px" frameborder="0"></iframe>
-                    </div>
-                    """
+                response_data = json.dumps(formatted_response).encode('utf-8')
                 
-                iframe_area = gr.HTML()
-                iframe_btn.click(show_iframe, outputs=iframe_area)
-        
-        # Ссылки на документацию и важные настройки
-        with gr.Accordion("Инструкции", open=False):
-            gr.Markdown("""
-            ### Важные настройки
-            
-            Для полноценной работы необходимо настроить следующие API ключи:
-            
-            1. **OpenAI API Key** - для работы с языковыми моделями
-            2. **Deepgram API Key** - для распознавания речи
-            3. **ElevenLabs API Key** - для синтеза речи
-            4. **Agora App ID и Certificate** - для работы с RTC
+                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)
+                print(f"Отправлен хардкодный ответ: {response_data.decode('utf-8')}")
+        else:
+            self.send_error(404, "Not Found")
             
-            ### Доступные графы
-            
-            1. **Voice Agent** - Голосовой агент с OpenAI и ElevenLabs
-            2. **Chat Agent** - Текстовый чат с OpenAI
-            """)
+    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()
+    
+    def do_GET(self):
+        print(f"Получен GET запрос: {self.path}")
         
-        # Статус серверов и логи
-        with gr.Accordion("Статус системы", open=False):
-            api_status = gr.Textbox(label="Статус API сервера", value="Проверка...", interactive=False)
-            ui_status = gr.Textbox(label="Статус UI сервера", value="Проверка...", interactive=False)
+        # Перенаправляем запрос /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"
+                        }
+                    ]
+                }
+            ]
             
-            # Функция обновления статуса
-            def update_status():
-                api_status_msg = "✅ Активен" if is_port_in_use(API_PORT) else "❌ Не активен"
-                ui_status_msg = "✅ Активен" if is_port_in_use(NEXTJS_PORT) else "❌ Не активен"
-                status_md_msg = f"### Статус: {'✅ Все системы работают' if is_port_in_use(API_PORT) and is_port_in_use(NEXTJS_PORT) else '⚠️ Есть проблемы'}"
-                return [api_status_msg, ui_status_msg, status_md_msg]
+            formatted_response = {
+                "data": extensions,
+                "status": 200,
+                "message": "Success"
+            }
             
-            status_btn = gr.Button("Обновить статус")
-            status_btn.click(update_status, outputs=[api_status, ui_status, status_md])
+            response_data = json.dumps(formatted_response).encode('utf-8')
             
-            # Обновляем статус при загрузке
-            demo.load(update_status, outputs=[api_status, ui_status, status_md])
-    
-    return demo
+            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)
+            print(f"Отправлен ответ для extensions: {response_data.decode('utf-8')}")
+        else:
+            self.send_error(404, "Not Found")
 
-# Вспомогательная функция для проверки, используется ли порт
-def is_port_in_use(port):
-    import socket
-    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-        try:
-            s.connect(('localhost', port))
-            return True
-        except:
-            return False
+def run_proxy_server():
+    """Запускает прокси-сервер на порту 49483"""
+    handler = ProxyHTTPRequestHandler
+    httpd = socketserver.TCPServer(("", 49483), handler)
+    print("Прокси-сервер запущен на порту 49483")
+    httpd.serve_forever()
 
-def create_simple_next_app(target_dir):
-    """Создает простое Next.js приложение в указанной директории"""
-    print(f"Создание простого Next.js приложения в {target_dir}")
-    
-    # Создаем базовую структуру Next.js приложения
-    app_dir = target_dir / "app"
-    app_dir.mkdir(exist_ok=True, parents=True)
-    
-    # Создаем простой package.json
-    package_json = {
-        "name": "ten-agent-simple-ui",
-        "version": "0.1.0",
-        "private": True,
-        "scripts": {
-            "dev": "next dev",
-            "build": "next build",
-            "start": "next start"
-        },
-        "dependencies": {
-            "next": "latest",
-            "react": "latest",
-            "react-dom": "latest"
-        }
-    }
-    
-    with open(target_dir / "package.json", "w") as f:
-        json.dump(package_json, f, indent=2)
-    
-    # Создаем простой next.config.js
-    next_config = """/** @type {import('next').NextConfig} */
-const nextConfig = {
-  reactStrictMode: true,
-}
-
-module.exports = nextConfig
-"""
-    
-    with open(target_dir / "next.config.js", "w") as f:
-        f.write(next_config)
-    
-    # Создаем простую страницу
-    page_content = """export default function Home() {
-  return (
-    <div style={{ padding: '20px', fontFamily: 'Arial, sans-serif' }}>
-      <h1>TEN Agent UI</h1>
-      <p>API server is running at: <a href="http://localhost:8080">http://localhost:8080</a></p>
-      
-      <div style={{ marginTop: '20px', padding: '10px', backgroundColor: '#f0f0f0', borderRadius: '5px' }}>
-        <p>API endpoints:</p>
-        <ul>
-          <li><a href="http://localhost:8080/graphs">/graphs</a> - Available graphs</li>
-          <li><a href="http://localhost:8080/health">/health</a> - API server status</li>
-        </ul>
-      </div>
-      
-      <div style={{ marginTop: '20px' }}>
-        <button 
-          style={{ 
-            padding: '10px 15px', 
-            backgroundColor: '#4CAF50', 
-            color: 'white',
-            border: 'none',
-            borderRadius: '5px',
-            cursor: 'pointer'
-          }}
-          onClick={() => window.location.href = 'http://localhost:8080/graphs'}
-        >
-          Go to API
-        </button>
-      </div>
-    </div>
-  );
-}
-"""
-    
-    with open(app_dir / "page.js", "w") as f:
-        f.write(page_content)
-    
-    # Создаем простой layout.js
-    layout_content = """export const metadata = {
-  title: 'TEN Agent',
-  description: 'Simple UI for TEN Agent',
-}
+def check_files():
+    """Проверяет и выводит информацию о важных файлах"""
+    files_to_check = [
+        "/app/agents/property.json",
+        "/app/agents/manifest.json",
+        "/app/agents/voice_agent.json",
+        "/app/agents/chat_agent.json",
+        "/app/server/bin/api"
+    ]
+    
+    print("\n=== Проверка критических файлов ===")
+    for file_path in files_to_check:
+        path = Path(file_path)
+        if path.exists():
+            if path.is_file():
+                size = path.stat().st_size
+                print(f"✅ {file_path} (размер: {size} байт)")
+                
+                # Если это JSON файл, выводим его содержимое
+                if file_path.endswith('.json'):
+                    try:
+                        with open(file_path, 'r') as f:
+                            content = json.load(f)
+                        print(f"   Содержимое: {json.dumps(content, indent=2)}")
+                    except Exception as e:
+                        print(f"   Ошибка чтения JSON: {e}")
+            else:
+                print(f"❌ {file_path} (это директория, а не файл)")
+        else:
+            print(f"❌ {file_path} (файл не найден)")
+    
+    print("\n=== Проверка структуры директорий ===")
+    print("Содержимое /app/agents:")
+    subprocess.run(["ls", "-la", "/app/agents"])
+    
+    print("\nПроверка прав доступа:")
+    subprocess.run(["stat", "/app/agents"])
+    subprocess.run(["stat", "/app/agents/property.json"])
 
-export default function RootLayout({ children }) {
-  return (
-    <html lang="en">
-      <body>{children}</body>
-    </html>
-  )
-}
-"""
+def test_api():
+    """Делает запрос к API для получения списка графов"""
+    import urllib.request
+    import urllib.error
     
-    with open(app_dir / "layout.js", "w") as f:
-        f.write(layout_content)
-    
-    print(f"Простое Next.js приложение создано в {target_dir}")
+    print("\n=== Тестирование API ===")
+    try:
+        # Даем серверу время запуститься
+        time.sleep(3)
+        with urllib.request.urlopen("http://localhost:8080/graphs") as response:
+            data = response.read().decode('utf-8')
+            print(f"Ответ /graphs: {data}")
+            
+            # Пробуем сделать запрос к нашему прокси
+            try:
+                with urllib.request.urlopen("http://localhost:49483/api/designer/v1/packages/reload") as proxy_response:
+                    proxy_data = proxy_response.read().decode('utf-8')
+                    print(f"Ответ от прокси: {proxy_data}")
+            except urllib.error.URLError as e:
+                print(f"Ошибка запроса к прокси: {e}")
+            
+    except urllib.error.URLError as e:
+        print(f"Ошибка запроса к API: {e}")
+    except Exception as e:
+        print(f"Неизвестная ошибка при запросе к API: {e}")
 
-def start_simple_ui():
-    """Запускает простой HTTP сервер для UI"""
-    print("Запуск простого HTTP сервера...")
-    
-    # Создаем директорию для UI
-    simple_ui_dir = Path("/tmp/ten_ui")
-    simple_ui_dir.mkdir(exist_ok=True, parents=True)
-    
-    # Создаем простую HTML страницу
-    html_content = """<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>TEN Agent Simple UI</title>
-    <style>
-        body {
-            font-family: Arial, sans-serif;
-            max-width: 800px;
-            margin: 0 auto;
-            padding: 20px;
-        }
-        .card {
-            background-color: #f5f5f5;
-            border-radius: 8px;
-            padding: 16px;
-            margin-bottom: 16px;
-        }
-        button {
-            background-color: #4CAF50;
-            border: none;
-            color: white;
-            padding: 10px 15px;
-            text-align: center;
-            text-decoration: none;
-            display: inline-block;
-            font-size: 16px;
-            margin: 4px 2px;
-            cursor: pointer;
-            border-radius: 4px;
-        }
-        a {
-            color: #0066cc;
-        }
-    </style>
-</head>
-<body>
-    <h1>TEN Agent UI</h1>
-    <div class="card">
-        <h2>API Server</h2>
-        <p>API сервер работает по адресу: <a href="http://localhost:8080" target="_blank">http://localhost:8080</a></p>
-        <p>Доступные эндпоинты:</p>
-        <ul>
-            <li><a href="http://localhost:8080/graphs" target="_blank">/graphs</a> - Список доступных графов</li>
-            <li><a href="http://localhost:8080/health" target="_blank">/health</a> - Статус API сервера</li>
-        </ul>
-    </div>
-    
-    <div class="card">
-        <h2>Запуск сессии</h2>
-        <p>Для запуска сессии можно использовать API вручную:</p>
-        <pre>curl -X POST http://localhost:8080/start -H "Content-Type: application/json" -d '{"graph_file":"voice_agent.json"}'</pre>
-    </div>
-</body>
-</html>
-"""
-    
-    with open(simple_ui_dir / "index.html", "w") as f:
-        f.write(html_content)
-    
-    # Запускаем простой HTTP сервер на порту 3000
-    server_cmd = f"cd {simple_ui_dir} && python -m http.server {NEXTJS_PORT}"
-    print(f"Running simple HTTP server: {server_cmd}")
-    
-    server_process = subprocess.Popen(
-        server_cmd,
-        shell=True,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE
-    )
-    
-    # Ждем запуска сервера
-    time.sleep(2)
-    
-    # Проверяем, что процесс не упал
-    if server_process.poll() is not None:
-        stdout, stderr = server_process.communicate()
-        print(f"Простой HTTP сервер не запустился!")
-        print(f"STDOUT: {stdout.decode()}")
-        print(f"STDERR: {stderr.decode()}")
-        return None
-    
-    print(f"Простой HTTP сервер запущен и слушает на порту {NEXTJS_PORT}")
-    return server_process
+def move_json_files_to_right_places():
+    """Копирует JSON файлы в нужные директории для работы с TEN-Agent"""
+    # Создаем структуру директорий, похожую на локальную установку
+    print("Создаем правильную структуру директорий для TEN-Agent...")
+    
+    target_dirs = [
+        "/app/agents",
+        "/app/agents/examples",
+        "/app/agents/examples/default",
+        "/app/agents/extensions"
+    ]
+    
+    for dir_path in target_dirs:
+        os.makedirs(dir_path, exist_ok=True)
+    
+    # Копируем voice_agent.json в директорию examples
+    source_file = "/app/agents/voice_agent.json"
+    target_file = "/app/agents/examples/voice_agent.json"
+    if os.path.exists(source_file):
+        shutil.copy2(source_file, target_file)
+        print(f"Файл скопирован: {source_file} -> {target_file}")
+    
+    # Копируем chat_agent.json в директорию examples
+    source_file = "/app/agents/chat_agent.json"
+    target_file = "/app/agents/examples/chat_agent.json"
+    if os.path.exists(source_file):
+        shutil.copy2(source_file, target_file)
+        print(f"Файл скопирован: {source_file} -> {target_file}")
+    
+    # Обновляем property.json с путями к файлам
+    property_path = "/app/agents/property.json"
+    if os.path.exists(property_path):
+        try:
+            with open(property_path, 'r') as f:
+                property_data = json.load(f)
+            
+            # Обновляем пути к файлам графов
+            for graph in property_data.get("graphs", []):
+                if "file" in graph:
+                    graph["file"] = f"examples/{graph['file']}"
+            
+            # Сохраняем обновленный файл
+            with open(property_path, 'w') as f:
+                json.dump(property_data, f, indent=2)
+            
+            print(f"Файл {property_path} обновлен с правильными путями")
+        except Exception as e:
+            print(f"Ошибка при обновлении {property_path}: {e}")
 
 def main():
-    # Создаем директории и файлы конфигурации
-    create_directories()
-    
-    # Пытаемся создать конфигурационные файлы
-    if not create_config_files():
-        print("ОШИБКА: Не удалось создать конфигурационные файлы!")
-        return 1
-    
-    # Запускаем API сервер
-    api_process = start_api_server()
-    if not api_process:
-        print("Не удалось запустить API сервер")
-        return 1
-    
-    # Пробуем запустить Playground UI через Next.js
-    ui_process = start_playground()
-    
-    # Если запуск через Next.js не удался, пробуем запустить простой HTTP сервер
-    if not ui_process:
-        print("Не удалось запустить Playground UI через Next.js, пробуем простой HTTP сервер...")
-        ui_process = start_simple_ui()
-        
-        if not ui_process:
-            print("Не удалось запустить ни один UI сервер. Продолжаем только с API сервером.")
-    
-    # Создаем Gradio интерфейс
-    demo = create_interface()
-    
-    # Запускаем Gradio
-    demo.launch(server_port=GRADIO_PORT, server_name=INTERNAL_HOST, share=False)
-    
-    # Остаемся в цикле до завершения процессов
+    processes = []
     try:
-        while True:
-            if api_process.poll() is not None:
-                print("API сервер остановлен")
-                if ui_process and ui_process.poll() is None:
-                    ui_process.terminate()
-                break
-            
-            if ui_process and ui_process.poll() is not None:
-                print("UI сервер остановлен, пробуем перезапустить...")
-                # Пробуем запустить простой HTTP сервер, если UI процесс упал
-                ui_process = start_simple_ui()
+        # Пути к исполняемым файлам
+        api_binary = Path("/app/server/bin/api")
+        playground_dir = Path("/app/playground")
+        
+        # Проверяем существование файлов
+        if not api_binary.exists():
+            print(f"ERROR: API binary not found at {api_binary}", file=sys.stderr)
+            return 1
+        
+        if not playground_dir.exists():
+            print(f"ERROR: Playground directory not found at {playground_dir}", file=sys.stderr)
+            return 1
+        
+        # Проверяем и создаем property.json
+        check_and_create_property_json()
+        
+        # Перемещаем файлы в нужные места
+        move_json_files_to_right_places()
+        
+        # Проверка файлов перед запуском
+        check_files()
+        
+        # Запускаем API сервер
+        print("Starting TEN-Agent API server on port 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()
+        
+        # Запускаем прокси-сервер на порту 49483
+        proxy_thread = threading.Thread(target=run_proxy_server)
+        proxy_thread.daemon = True
+        proxy_thread.start()
+        
+        # Запускаем Playground UI в режиме dev на порту 7860 (порт Hugging Face)
+        print("Starting Playground UI in development mode on port 7860...")
+        os.environ["PORT"] = "7860"
+        os.environ["AGENT_SERVER_URL"] = "http://localhost:8080"
+        os.environ["NEXT_PUBLIC_EDIT_GRAPH_MODE"] = "true"  # Включаем расширенный режим редактирования
+        os.environ["NEXT_PUBLIC_DISABLE_CAMERA"] = "true"  # Отключаем запрос на использование камеры
+        
+        playground_process = subprocess.Popen(
+            ["pnpm", "dev"],
+            cwd=str(playground_dir),
+            env=os.environ
+        )
+        processes.append(playground_process)
+        
+        # Ожидаем завершения процессов
+        for proc in processes:
+            proc.wait()
             
-            time.sleep(1)
     except KeyboardInterrupt:
-        print("Принудительная остановка...")
-        api_process.terminate()
-        if ui_process:
-            ui_process.terminate()
+        print("Shutting down...")
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+    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