app.py

#!/usr/bin/env python3
import os
import subprocess
import sys
import time
import json
from pathlib import Path
import signal
import threading
import shutil
import logging
import urllib.request
import urllib.error
import tempfile

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

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

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

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

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

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

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

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

def test_api():
    """Делает запрос к API для получения списка графов"""
    logger.info("=== Тестирование API ===")
    try:
        # Даем серверу время запуститься
        time.sleep(3)
        with urllib.request.urlopen("http://localhost:8080/graphs") as response:
            data = response.read().decode('utf-8')
            logger.info(f"Ответ /graphs: {data}")
            
            # Проверяем структуру ответа
            try:
                json_data = json.loads(data)
                if isinstance(json_data, list) and len(json_data) > 0:
                    logger.info(f"API вернул {len(json_data)} графов")
                    # Если API вернул пустой список, исправляем это
                    if len(json_data) == 0:
                        logger.warning("API вернул пустой список графов, исправляем property.json")
                        backup_file(PROPERTY_JSON)
                        check_and_create_property_json()
                        check_and_create_agent_files()
                        ensure_directory_permissions(AGENTS_DIR)
                        # Перезапускаем API сервер
                        logger.info("Перезапускаем API сервер...")
                        subprocess.run(["pkill", "-f", str(API_BINARY)])
                        time.sleep(1)
                        subprocess.Popen([str(API_BINARY)])
                else:
                    logger.warning("API вернул пустой список графов")
            except json.JSONDecodeError:
                logger.error("Ответ API не является валидным JSON")
    except urllib.error.URLError as e:
        logger.error(f"Ошибка запроса к API: {e}")
    except Exception as e:
        logger.error(f"Неизвестная ошибка при запросе к API: {e}")

def main():
    processes = []
    try:
        # Проверяем существование файлов
        if not API_BINARY.exists():
            logger.error(f"API binary не найден: {API_BINARY}")
            return 1
        
        if not PLAYGROUND_DIR.exists():
            logger.error(f"Playground директория не найдена: {PLAYGROUND_DIR}")
            return 1
        
        # Создаем директории и устанавливаем права
        ensure_directory_permissions(AGENTS_DIR)
        ensure_directory_permissions(BACKUP_DIR)
        
        # Проверяем и создаем property.json
        check_and_create_property_json()
        
        # Проверяем и создаем файлы агентов
        check_and_create_agent_files()
        
        # Проверка файлов перед запуском
        check_files()
        
        # Запускаем API сервер
        logger.info("Запуск TEN-Agent API сервера на порту 8080...")
        api_process = subprocess.Popen([str(API_BINARY)])
        processes.append(api_process)
        
        # Тестируем API
        test_thread = threading.Thread(target=test_api)
        test_thread.daemon = True
        test_thread.start()
        
        # Запускаем Playground UI в режиме dev на порту 7860 (порт Hugging Face)
        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 UI
        playground_process = subprocess.Popen(
            ["pnpm", "dev"],
            cwd=str(PLAYGROUND_DIR),
            env=os.environ
        )
        processes.append(playground_process)
        
        # Ожидаем завершения процессов
        for proc in processes:
            proc.wait()
            
    except KeyboardInterrupt:
        logger.info("Завершение работы...")
    except Exception as e:
        logger.error(f"Ошибка: {e}")
    finally:
        # Завершение процессов
        for proc in processes:
            if proc and proc.poll() is None:
                proc.terminate()
                try:
                    proc.wait(timeout=5)
                except subprocess.TimeoutExpired:
                    proc.kill()
    
    return 0

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