Радикальное исправление проблемы с Select Graph путем добавления мок-эндпоинтов дизайнера

Dockerfile

@@ -1,13 +1,8 @@
 FROM ubuntu:22.04
 
-# Установка базовых пакетов
-RUN apt-get update && apt-get install -y \
-    curl \
-    git \
-    wget \
-    make \
-    gcc \
-    build-essential \
+# Принудительное обновление для HuggingFace, чтобы использовать правильную версию Dockerfile
+# Установка необходимых пакетов
+RUN apt-get clean && apt-get update && apt-get install -y --no-install-recommends \
     libasound2 \
     libgstreamer1.0-dev \
     libunwind-dev \
@@ -17,89 +12,160 @@ RUN apt-get update && apt-get install -y \
     python3-venv \
     python3-pip \
     python3-dev \
+    curl \
+    wget \
     unzip \
+    git \
+    build-essential \
     jq \
     vim \
     ca-certificates \
-    gnupg \
-    lsb-release \
-    net-tools \
-    procps \
     && apt-get clean && rm -rf /var/lib/apt/lists/* && rm -rf /tmp/*
 
-# Установка Go
+# Установка Go 1.21
 RUN wget https://golang.org/dl/go1.21.0.linux-amd64.tar.gz && \
     tar -C /usr/local -xzf go1.21.0.linux-amd64.tar.gz && \
     rm go1.21.0.linux-amd64.tar.gz
-
-# Настройка окружения Go
 ENV PATH=$PATH:/usr/local/go/bin
 ENV GOPATH=/go
 ENV PATH=$PATH:$GOPATH/bin
-RUN mkdir -p /go && chmod 777 /go
 
-# Создание директории для кэша Go
-ENV GOCACHE=/tmp/go-cache
-RUN mkdir -p /tmp/go-cache && chmod 777 /tmp/go-cache
+# Создаем каталог для кэша Go и устанавливаем правильные разрешения
+RUN mkdir -p /go && chmod 777 /go
 
 # Установка Node.js и pnpm
 RUN curl -fsSL https://deb.nodesource.com/setup_20.x | bash - && \
     apt-get install -y nodejs && \
     npm install -g pnpm
 
-# Клонирование репозитория TEN-Agent
+# Устанавливаем рабочую директорию
 WORKDIR /app
-RUN git clone --depth 1 https://github.com/TEN-framework/TEN-Agent.git /app-temp && \
-    mv /app-temp/* /app/ && \
-    mv /app-temp/.* /app/ 2>/dev/null || true && \
-    rm -rf /app-temp
-
-# Создание пользовательских директорий для временных файлов
-RUN mkdir -p /tmp/ten_user && chmod 777 /tmp/ten_user
-RUN mkdir -p /tmp/ten_user/agents && chmod 777 /tmp/ten_user/agents
-RUN mkdir -p /tmp/ten_user/logs && chmod 777 /tmp/ten_user/logs
-RUN mkdir -p /tmp/ten_user/rag_data && chmod 777 /tmp/ten_user/rag_data
-RUN mkdir -p /app/backup && chmod 777 /app/backup
-
-# Компиляция API сервера (для справки, мы будем использовать Python-реализацию)
+
+# Клонируем репозиторий TEN-Agent
+RUN git clone --depth 1 https://github.com/TEN-framework/TEN-Agent.git /app && \
+    echo "Доступные ветки и теги:" && \
+    git branch -a && \
+    git tag -l
+
+# Устанавливаем task для сборки
+RUN go install github.com/go-task/task/v3/cmd/task@latest
+
+# Создаем необходимые директории и устанавливаем права
 RUN mkdir -p /app/server/bin && \
-    cd /app/server && \
-    GOCACHE=/tmp/go-cache go build -o bin/api main.go && \
+    mkdir -p /app/agents && \
+    mkdir -p /tmp/ten_agent && \
+    mkdir -p /app/.pnpm-store
+
+# Копируем .env файл
+COPY .env /app/.env
+
+# Патчим файл конфигурации Next.js, чтобы перенаправлять запросы к дизайнеру на наш API
+RUN echo 'module.exports = {  \
+    async rewrites() {  \
+    return [  \
+    {  \
+    source: "/api/designer/:path*",  \
+    destination: "/api/agents/:path*",  \
+    },  \
+    {  \
+    source: "/api/dev/:path*",  \
+    destination: "/api/agents/:path*",  \
+    },  \
+    ];  \
+    },  \
+    };' > /app/playground/next.config.js
+
+# Патчим API сервер для обработки запросов дизайнера
+RUN echo 'package main\n\nimport (\n\t"net/http"\n\t\n\t"github.com/gin-gonic/gin"\n)\n\nfunc init() {\n\t// Добавляем обработчик для дизайнера\n\tregisterDesignerHandlers()\n}\n\nfunc registerDesignerHandlers() {\n\t// Регистрация дополнительных обработчиков в gin\n\thttp.DefaultServeMux.HandleFunc("/api/designer/v1/packages/reload", func(w http.ResponseWriter, r *http.Request) {\n\t\tw.Header().Set("Content-Type", "application/json")\n\t\tw.WriteHeader(http.StatusOK)\n\t\tw.Write([]byte(`{"success":true}`))\n\t})\n\n\thttp.DefaultServeMux.HandleFunc("/api/dev/v1/packages/reload", func(w http.ResponseWriter, r *http.Request) {\n\t\tw.Header().Set("Content-Type", "application/json")\n\t\tw.WriteHeader(http.StatusOK)\n\t\tw.Write([]byte(`{"success":true}`))\n\t})\n}' > /app/server/designer_handlers.go
+
+# Компилируем сервер
+RUN cd /app/server && \
+    go mod tidy && \
+    go mod download && \
+    go build -o bin/api main.go && \
     chmod +x bin/api
 
-# Проверяем, что API сервер скомпилирован
-RUN ls -la /app/server/bin/api || echo "API server not compiled"
-
-# Предварительная установка зависимостей для playground
-# Делаем это отдельно, чтобы не пересобирать при каждом изменении
-RUN cd /app/playground && pnpm install
-
-# Запускаем playground один раз для предварительной сборки
-RUN cd /app/playground && pnpm build || echo "Failed to build playground, but continuing"
-
-# Копируем наши скрипты
-COPY fallback.py /app/fallback.py
-COPY api_wrapper.py /app/api_wrapper.py
-COPY start.sh /app/start.sh
-RUN chmod +x /app/start.sh /app/fallback.py /app/api_wrapper.py
-
-# Устанавливаем переменные окружения для HuggingFace
-ENV HF_SPACE=true
-ENV AGENT_SERVER_URL=http://localhost:8080
-ENV NEXT_PUBLIC_EDIT_GRAPH_MODE=true
-ENV NEXT_PUBLIC_DISABLE_CAMERA=true
-ENV PORT=7860
-ENV API_PORT=8080
-ENV TEN_AGENT_DIR=/tmp/ten_user/agents
-ENV PYTHONUNBUFFERED=1
-
-# Открываем порты (7860 для HF Space, 8080 для API)
-EXPOSE 7860 8080
-
-# Предварительно создаем важные файлы
-RUN mkdir -p /app/agents
-RUN echo '{"_ten":{"version":"0.0.1"},"name":"default","agents":[{"name":"voice_agent","description":"A simple voice agent","type":"voice"}]}' > /app/agents/manifest.json
-RUN echo '{"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"}]}' > /app/agents/property.json
-
-# Запускаем TEN-Agent через fallback скрипт
-CMD ["/app/start.sh"]
+# Установка зависимостей для Playground UI
+ENV PNPM_HOME="/app/.pnpm-store"
+ENV PATH="$PNPM_HOME:$PATH"
+RUN cd /app/playground && \
+    pnpm install
+
+# Подготавливаем пример агента для работы Select Graph
+RUN cd /app && \
+    mkdir -p agents/examples && \
+    mkdir -p agents/examples/default && \
+    mkdir -p agents/examples/demo && \
+    mkdir -p agents/examples/experimental
+
+# Копируем примеры из репозитория
+RUN cd /app && \
+    cp -r agents/examples/default agents/ && \
+    cp -r agents/examples/demo agents/ && \
+    cp -r agents/examples/experimental agents/
+
+# Создаем базовый manifest.json
+RUN echo '{\n\
+    "name": "default",\n\
+    "agents": [\n\
+    {\n\
+    "name": "voice_agent",\n\
+    "description": "A simple voice agent"\n\
+    },\n\
+    {\n\
+    "name": "chat_agent",\n\
+    "description": "A text chat agent"\n\
+    }\n\
+    ]\n\
+    }' > /app/agents/manifest.json
+
+# Создаем базовый property.json в формате TEN
+RUN echo '{\n\
+    "_ten": {},\n\
+    "name": "TEN Agent Example",\n\
+    "version": "0.0.1",\n\
+    "extensions": ["openai_chatgpt"],\n\
+    "description": "A basic voice agent with OpenAI",\n\
+    "graphs": [\n\
+    {\n\
+    "name": "Voice Agent",\n\
+    "description": "Basic voice agent with OpenAI",\n\
+    "file": "voice_agent.json"\n\
+    },\n\
+    {\n\
+    "name": "Chat Agent",\n\
+    "description": "Simple chat agent",\n\
+    "file": "chat_agent.json"\n\
+    }\n\
+    ]\n\
+    }' > /app/agents/property.json
+
+# Создаем простые примеры графов
+RUN echo '{\n\
+    "nodes": [],\n\
+    "edges": [],\n\
+    "groups": [],\n\
+    "templates": [],\n\
+    "root": null\n\
+    }' > /app/agents/voice_agent.json
+
+RUN echo '{\n\
+    "nodes": [],\n\
+    "edges": [],\n\
+    "groups": [],\n\
+    "templates": [],\n\
+    "root": null\n\
+    }' > /app/agents/chat_agent.json
+
+# Устанавливаем правильные права доступа для всех файлов
+RUN chmod -R 777 /app
+
+# Настраиваем стартовый скрипт
+COPY app.py /app/app.py
+RUN chmod +x /app/app.py
+
+# Открываем порты
+EXPOSE 7860 8080 3000
+
+# Запускаем API сервер и Playground в dev-режиме
+ENTRYPOINT ["python3", "/app/app.py"]

app.py

@@ -8,19 +8,24 @@ from pathlib import Path
 import signal
 import threading
 import shutil
-import http.server
-import socketserver
-import urllib.request
-import urllib.error
+import logging
+
+# Настройка логирования
+logging.basicConfig(level=logging.INFO, 
+                    format='%(asctime)s [%(levelname)s] %(message)s',
+                    datefmt='%Y-%m-%d %H:%M:%S')
+
+logger = logging.getLogger('ten-agent')
 
 def check_and_create_property_json():
     """Проверяет наличие property.json и создает его при необходимости"""
     property_path = Path("/app/agents/property.json")
     
     if not property_path.exists():
-        print(f"WARNING: {property_path} не найден, создаем файл...")
+        logger.warning(f"{property_path} не найден, создаем файл...")
         
         property_data = {
+            "_ten": {},  # Важное поле для TEN формата
             "name": "TEN Agent Example",
             "version": "0.0.1",
             "extensions": ["openai_chatgpt"],
@@ -46,189 +51,7 @@ def check_and_create_property_json():
         with open(property_path, 'w') as f:
             json.dump(property_data, f, indent=2)
             
-        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)
-                
-                # Проверяем наличие _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:
-                        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"]
-                
-                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')}")
-        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()
-    
-    def do_GET(self):
-        print(f"Получен GET запрос: {self.path}")
-        
-        # Перенаправляем запрос /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)
-            print(f"Отправлен ответ для extensions: {response_data.decode('utf-8')}")
-        else:
-            self.send_error(404, "Not Found")
-
-def run_proxy_server():
-    """Запускает прокси-сервер на порту 49483"""
-    handler = ProxyHTTPRequestHandler
-    httpd = socketserver.TCPServer(("", 49483), handler)
-    print("Прокси-сервер запущен на порту 49483")
-    httpd.serve_forever()
+        logger.info(f"Файл {property_path} создан успешно")
 
 def check_files():
     """Проверяет и выводит информацию о важных файлах"""
@@ -240,109 +63,86 @@ def check_files():
         "/app/server/bin/api"
     ]
     
-    print("\n=== Проверка критических файлов ===")
+    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
-                print(f"✅ {file_path} (размер: {size} байт)")
+                logger.info(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)}")
+                        logger.info(f"   Содержимое: {json.dumps(content, indent=2)}")
                     except Exception as e:
-                        print(f"   Ошибка чтения JSON: {e}")
+                        logger.error(f"   Ошибка чтения JSON: {e}")
             else:
-                print(f"❌ {file_path} (это директория, а не файл)")
+                logger.warning(f"❌ {file_path} (это директория, а не файл)")
         else:
-            print(f"❌ {file_path} (файл не найден)")
+            logger.error(f"❌ {file_path} (файл не найден)")
     
-    print("\n=== Проверка структуры директорий ===")
-    print("Содержимое /app/agents:")
+    logger.info("=== Проверка структуры директорий ===")
+    logger.info("Содержимое /app/agents:")
     subprocess.run(["ls", "-la", "/app/agents"])
     
-    print("\nПроверка прав доступа:")
+    logger.info("Проверка прав доступа:")
     subprocess.run(["stat", "/app/agents"])
     subprocess.run(["stat", "/app/agents/property.json"])
 
+def setup_mock_designer():
+    """Настраивает мок-эндпоинты для дизайнера"""
+    # Создаем файл с мок-ответом для запросов
+    mock_dir = Path("/app/mock_responses")
+    mock_dir.mkdir(exist_ok=True)
+    
+    reload_response = {
+        "success": True,
+        "packages": [
+            {
+                "name": "default",
+                "description": "Default package",
+                "graphs": [
+                    {"name": "Voice Agent", "description": "Voice Agent with OpenAI", "file": "voice_agent.json"},
+                    {"name": "Chat Agent", "description": "Simple Chat Agent", "file": "chat_agent.json"}
+                ]
+            }
+        ]
+    }
+    
+    with open(mock_dir / "reload_response.json", "w") as f:
+        json.dump(reload_response, f, indent=2)
+    
+    logger.info("Мок-файлы для дизайнера созданы")
+
 def test_api():
     """Делает запрос к API для получения списка графов"""
     import urllib.request
     import urllib.error
     
-    print("\n=== Тестирование API ===")
+    logger.info("=== Тестирование 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}")
+            logger.info(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}")
-            
+                json_data = json.loads(data)
+                if isinstance(json_data, list) and len(json_data) > 0:
+                    logger.info(f"API вернул {len(json_data)} графов")
+                else:
+                    logger.warning("API вернул пус��ой список графов")
+            except json.JSONDecodeError:
+                logger.error("Ответ API не является валидным JSON")
     except urllib.error.URLError as e:
-        print(f"Ошибка запроса к API: {e}")
+        logger.error(f"Ошибка запроса к API: {e}")
     except Exception as e:
-        print(f"Неизвестная ошибка при запросе к API: {e}")
-
-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}")
+        logger.error(f"Неизвестная ошибка при запросе к API: {e}")
 
 def main():
     processes = []
@@ -353,24 +153,24 @@ def main():
         
         # Проверяем существование файлов
         if not api_binary.exists():
-            print(f"ERROR: API binary not found at {api_binary}", file=sys.stderr)
+            logger.error(f"API binary не найден: {api_binary}")
             return 1
         
         if not playground_dir.exists():
-            print(f"ERROR: Playground directory not found at {playground_dir}", file=sys.stderr)
+            logger.error(f"Playground директория не найдена: {playground_dir}")
             return 1
         
         # Проверяем и создаем property.json
         check_and_create_property_json()
         
-        # Перемещаем файлы в нужные места
-        move_json_files_to_right_places()
+        # Создаем мок-файлы для дизайнера
+        setup_mock_designer()
         
         # Проверка файлов перед запуском
         check_files()
         
         # Запускаем API сервер
-        print("Starting TEN-Agent API server on port 8080...")
+        logger.info("Запуск TEN-Agent API сервера на порту 8080...")
         api_process = subprocess.Popen([str(api_binary)])
         processes.append(api_process)
         
@@ -379,18 +179,18 @@ def main():
         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...")
+        logger.info("Запуск Playground UI в режиме разработки на порту 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"  # Отключаем запрос на использование камеры
         
+        # Важные переменные для отключения запросов к дизайнеру
+        os.environ["NEXT_PUBLIC_DEV_MODE"] = "false"
+        os.environ["NEXT_PUBLIC_API_BASE_URL"] = "/api/agents"
+        os.environ["NEXT_PUBLIC_DESIGNER_API_URL"] = "http://localhost:8080"
+        
         playground_process = subprocess.Popen(
             ["pnpm", "dev"],
             cwd=str(playground_dir),
@@ -403,9 +203,9 @@ def main():
             proc.wait()
             
     except KeyboardInterrupt:
-        print("Shutting down...")
+        logger.info("Завершение работы...")
     except Exception as e:
-        print(f"Error: {e}", file=sys.stderr)
+        logger.error(f"Ошибка: {e}")
     finally:
         # Завершение процессов
         for proc in processes: