SenSu/main.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import logging
import asyncio
import sys
import signal
import time
import argparse
from services.project_engine import ProjectEngine
from services.pyenv_manager import PyEnvManager
from services.proxy_service import ProxyService
import os
from pathlib import Path

# 添加项目根目录到Python路径
project_root = Path(__file__).parent
sys.path.insert(0, str(project_root))

from services.init_service import InitService
from services.log_service import LogService
from services.tui_service import TuiService
from services.command_service import CommandService
from services.auth_service import AuthService
from services.internet_service import InternetService
from services.plugin_service import PluginService
from services.permission_service import PermissionService
from services.api_service import APIService
from services.shutdown_service import ShutdownService
from services.web_panel.manager import WebPanelManager 

from bridges.core_bridge import CoreBridge
from bridges.plugin_bridge import PluginBridge
from service_manager import ServiceManager

logger = logging.getLogger(__name__)

class SenSuFramework:
    """框架主类"""
    
    def __init__(self, headless=False):
        self.service_manager = ServiceManager()
        self.is_running = False
        self.headless = headless
        logger.debug("🐱 SenSu 框架初始化开始")
    
    async def initialize(self):
        """初始化框架"""
        try:
            logger.info("🐱 SenSu 启动中...")
            
            # 1. 初始化服务
            init_service = InitService()
            configs = await init_service.initialize_framework()
            base_config = configs['base']
            self.service_manager.register_service("init", init_service)
            
            # 2. 日志服务
            log_service = LogService(base_config)
            self.service_manager.register_service("log", log_service)
            
            # 3. 核心桥接服务
            core_bridge = CoreBridge()
            await core_bridge.start()
            self.service_manager.register_service("core_bridge", core_bridge)
            
            # 4. 指令服务
            command_service = CommandService(self.service_manager)
            command_service.register_builtin_commands()
            self.service_manager.register_service("command", command_service)
                    
            # 5. 认证服务
            logger.info("> 初始化 访问认证 ...")
            auth_service = AuthService(base_config)
            self.service_manager.register_service("auth", auth_service)
                                                                    
            # 6. 插件桥接服务
            logger.info("> 初始化 插件桥 ...")
            plugin_bridge = PluginBridge(core_bridge)
            await plugin_bridge.start()
            self.service_manager.register_service("plugin_bridge", plugin_bridge)
            
            # 7. 关闭服务
            logger.info("> 初始化 关闭服务 中...")
            shutdown_service = ShutdownService(self.service_manager)
            self.service_manager.register_service("shutdown", shutdown_service)            
    
            # 8. TUI服务
            if self.headless:
                logger.info("Headless mode, skip TUI")
                self.service_manager.register_service("tui", self._create_fallback_tui())
            else:
                try:
                    tui_service = TuiService(base_config, log_service, command_service)
                    await tui_service.start()
                    self.service_manager.register_service("tui", tui_service)
                    logger.info("TUI服务启动成功")
                except Exception as e:
                    logger.warning(f"TUI服务启动失败: {e}")
                    self.service_manager.register_service("tui", self._create_fallback_tui())
    
            # 9. 权限服务
            logger.info("> 初始化 权限服务 中...")
            permission_service = PermissionService(base_config, self.service_manager.get_service("tui"), core_bridge)
            permission_started = await permission_service.start()
            if permission_started:
                self.service_manager.register_service("permission", permission_service)
            else:
                logger.warning("权限服务启动失败，跳过注册")
    
            # 10. 互联网服务（提前创建但不启动）
            logger.info("> 初始化 网络服务 中...")
            internet_service = InternetService(base_config, self.service_manager)
            self.service_manager.register_service("internet", internet_service)
    
            # 11. 插件服务（在网络服务启动前注册路由）
            logger.info("> 初始化 插件管理器 中...")
            plugin_service = PluginService(base_config, permission_service, plugin_bridge, self.service_manager)
            await plugin_service.start()
            self.service_manager.register_service("plugin", plugin_service)

            # === 🟢 新增: 11.5 Web管理面板初始化 (必须在网络服务启动前!) ===
            # 原因: aiohttp 启动后会“冻结”路由器，之后再挂载子应用会报错
            logger.info("> 初始化 Web 管理面板 中...")
            try:
                # 确保 internet_service 已经实例化（在第10步）
                if internet_service: 
                    from services.web_panel.manager import WebPanelManager
                    
                    # 初始化面板管理器
                    web_panel = WebPanelManager(base_config, self.service_manager)
                    
                    # 这里的 start() 会把面板路由挂载到 http_app 上 (此时还未冻结)
                    if await web_panel.start():
                        self.service_manager.register_service("web_panel", web_panel)
                        logger.info("✅ Web 面板挂载完成")
                    else:
                        logger.warning("Web 面板初始化未完成")
            except Exception as e:
                logger.error(f"❌ Web 管理面板初始化失败: {str(e)}", exc_info=True)

            # 12. 启动网络服务（在所有插件路由注册后）
            logger.info("> 启动网络服务 中...")
            try:
                # 先检查依赖和端口
                health_info = await internet_service.check_service_health()
                logger.debug(f"网络服务预检查: {health_info}")
                
                if not health_info["dependencies_available"]:
                    logger.error("❌ 缺少必要的依赖包，网络服务无法启动")
                    logger.info("💡 请运行: pip install aiohttp yaml")
                    internet_started = False
                else:
                    # 现在启动网络服务（路由器会在启动时冻结）
                    internet_started = await internet_service.start()
                    
                    # 再次检查服务状态
                    if internet_started:
                        post_health = await internet_service.check_service_health()
                        logger.debug(f"网络服务启动后检查: {post_health}")
                        
                        if post_health["http_active"]:
                            logger.info("✅ 互联网服务启动成功")
                            
                            # 显示服务信息
                            logger.info(f"🌐 服务地址: http://{internet_service.http_host}:{internet_service.http_port}")
                            logger.info(f"🔍 健康检查: http://{internet_service.http_host}:{internet_service.http_port}/health")
                        else:
                            logger.warning("⚠️ 网络服务已启动但端口未响应")
                    else:
                        logger.warning("❌ 互联网服务启动失败")
                        
            except Exception as e:
                logger.error(f"❌ 互联网服务启动异常: {str(e)}", exc_info=True)
                logger.warning("互联网服务启动失败")
          
            # 13. API服务
            logger.info("> 初始化 API 服务 中...")
            try:
                api_service = APIService(internet_service, auth_service, permission_service)
                self.service_manager.register_service("api", api_service)
                logger.info("✅ API 服务启动成功")
                
            except Exception as e:
                logger.error(f"❌ API 服务初始化失败: {str(e)}")
                logger.warning("API 服务启动失败，跳过注册")
            

            # 注册框架关闭处理器
            shutdown_service.register_shutdown_handler(self._framework_shutdown_handler)
            # 11.7 项目引擎 + 反向代理
            try:
                logger.info("> 初始化 项目引擎 中...")
                project_engine = ProjectEngine(self.service_manager)
                await project_engine.start()
                self.service_manager.register_service("project_engine", project_engine)
                pe_mgr = PyEnvManager("data/projects")
                self.service_manager.register_service("pyenv", pe_mgr)

                logger.info("> 初始化 反向代理 中...")
                proxy_service = ProxyService(self.service_manager)
                await proxy_service.start()
                self.service_manager.register_service("proxy", proxy_service)
                logger.info("✅ 项目引擎+反向代理就绪")
            except Exception as e:
                logger.warning(f"引擎/代理初始化跳过: {e}")

            logger.info("🎉 SenSu 初始化完成！")
            self.service_manager.start_time = time.time()
            self.is_running = True
            
            # 显示欢迎日志
            version = base_config.get('framework', {}).get('version', 'Unknown')
            logLevel = base_config.get('logging', {}).get('level', 'Unknown') 
    
            logger.info("\n🐱 SenSu 已就绪！")
            logger.info(f"当前 SenSu 版本号 {version}")                
            logger.info(f"当前日志级别 {logLevel}")
            
            panel_path = base_config.get('panel', {}).get('entrance', {}).get('path', 'panel')
            
            # 显示欢迎消息    
            tui_service = self.service_manager.get_service("tui")
            if hasattr(tui_service, 'show_message'):
                tui_service.show_message("🐱 SenSu 框架 已就绪！\n", "info")
                tui_service.show_message("====================================\n", "info")
                tui_service.show_message("🐱 SenSu 已就绪！", "info")
                tui_service.show_message(f"当前 SenSu 版本号 {version}", "info")                
                tui_service.show_message(f"当前日志级别 {logLevel}\n", "info")
                tui_service.show_message("====================================\n", "info")               
                tui_service.show_message(f"当前API配置地址", "debug")
                tui_service.show_message(f"地址:http://{internet_service.http_host}:{internet_service.http_port}", "debug")
                tui_service.show_message("====================================\n", "debug")   
                tui_service.show_message(f"🌐 Web 面板配置地址: http://{internet_service.http_host}:{internet_service.http_port}{panel_path}", "info")
                
            else:
                print("🐱 SenSu 已就绪！输入 'help' 查看可用命令")
            
        except Exception as e:
            logger.error(f"框架初始化失败: {str(e)}", exc_info=True)
            await self._safe_shutdown()
            raise

    
    def _create_fallback_tui(self):
        """创建回退的TUI服务（命令行模式）"""
        class FallbackTuiService:
            def __init__(self):
                self.is_running = True
            
            def show_message(self, message: str, msg_type: str = "info", persistent: bool = False):
                """显示消息到控制台"""
                prefix = {
                    "info": "ℹ️",
                    "warning": "⚠️", 
                    "error": "❌",
                    "success": "✅"
                }.get(msg_type, "📝")
                print(f"{prefix} {message}")
            
            async def start(self):
                """启动回退TUI"""
                print("🐱 使用命令行模式...")
                return True
            
            def shutdown(self):
                """关闭回退TUI"""
                self.is_running = False
        
        return FallbackTuiService()
    
    async def _safe_shutdown(self):
        """安全关闭，即使服务未完全初始化"""
        try:
            logger.info("执行安全关闭")
            self.is_running = False
            
            # 尝试获取关闭服务
            try:
                shutdown_service = self.service_manager.get_service("shutdown")
                if shutdown_service:
                    await shutdown_service.initiate_shutdown("安全关闭")
                    return
            except:
                pass
            
            # 如果关闭服务不可用，手动关闭其他服务
            services_to_shutdown = ['plugin', 'core_bridge', 'plugin_bridge', 'tui', 'log']
            for service_name in services_to_shutdown:
                try:
                    service = self.service_manager.get_service(service_name)
                    if service and hasattr(service, 'shutdown'):
                        await service.shutdown() if asyncio.iscoroutinefunction(service.shutdown) else service.shutdown()
                except:
                    pass
            
            logger.debug("安全关闭完成")
            
        except Exception as e:
            print(f"❌ 安全关闭时出错: {e}")
    
    async def _framework_shutdown_handler(self):
        """框架关闭处理器"""
        try:
            logger.info("执行框架关闭处理")
            self.is_running = False
            
            # 关闭插件服务
            plugin_service = self.service_manager.get_service("plugin")
            if plugin_service:
                # 卸载所有插件
                for plugin_name in list(plugin_service.plugins.keys()):
                    await plugin_service.unload_plugin(plugin_name)
            
            # 关闭桥接服务
            core_bridge = self.service_manager.get_service("core_bridge")
            if core_bridge:
                await core_bridge.shutdown()
            
            plugin_bridge = self.service_manager.get_service("plugin_bridge")
            if plugin_bridge:
                await plugin_bridge.shutdown()
            
            logger.debug("框架关闭处理完成")
            
        except Exception as e:
            logger.error(f"框架关闭处理时出错: {str(e)}", exc_info=True)
    
    async def run(self):
        """运行框架主循环"""
        try:
            logger.info("进入框架主循环")
            
            # 特殊终端，添加命令行输入处理
            tui = self.service_manager.get_service("tui")
            if self.headless:
                while self.is_running:
                    try: await asyncio.sleep(1)
                    except asyncio.CancelledError: break
            elif not hasattr(tui, 'tui_app'):
                await self._run_cli_mode()
            else:
                # 原有的TUI模式
                while self.is_running:
                    try:
                        await asyncio.sleep(1)        
                    except asyncio.CancelledError:
                        logger.info("主循环被取消")
                        break
                    except Exception as e:
                        logger.error(f"主循环运行时出错: {str(e)}", exc_info=True)
                        await asyncio.sleep(5)
            
            logger.info("框架主循环结束")
            
        except Exception as e:
            logger.error(f"运行框架主循环时出错: {str(e)}", exc_info=True)
            await self._safe_shutdown()
    
    async def _run_cli_mode(self):
        """运行命令行模式"""
        try:
            print("🐱 进入命令行模式，输入 'exit' 退出")
            
            command_service = self.service_manager.get_service("command")
            
            while self.is_running:
                try:
                    # 读取用户输入
                    user_input = await asyncio.get_event_loop().run_in_executor(
                        None, input, "🐱 > "
                    )
                    
                    if user_input.strip().lower() in ('exit', 'quit', 'q'):
                        await self.shutdown()
                        break
                    
                    # 处理命令
                    if user_input.strip():
                        result = await command_service.process_command(user_input, "cli")
                        print(f"📝 {result}")
                    
                except (KeyboardInterrupt, EOFError):
                    print("\n🐱 接收到退出信号")
                    await self.shutdown()
                    break
                except Exception as e:
                    print(f"❌ 命令处理错误: {str(e)}")
                    
        except Exception as e:
            logger.error(f"命令行模式运行时出错: {str(e)}", exc_info=True)
            await self._safe_shutdown()
    
    async def shutdown(self):
        """关闭框架"""
        try:
            logger.info("开始关闭框架")
            self.is_running = False
            
            # 通过关闭服务发起优雅关闭
            shutdown_service = self.service_manager.get_service("shutdown")
            if shutdown_service:
                await shutdown_service.initiate_shutdown("手动关闭")
            else:
                await self._safe_shutdown()
            
        except Exception as e:
            logger.error(f"关闭框架时出错: {str(e)}", exc_info=True)
            await self._safe_shutdown()

async def main(headless=False):
    """主函数"""
    framework = SenSuFramework(headless=headless)
    
    try:
        # 初始化框架
        await framework.initialize()
        
        # 运行主循环
        await framework.run()
         
    except KeyboardInterrupt:
        print("\n🐱 接收到键盘中断")
        await framework.shutdown()
    except Exception as e:
        print(f"🐱 框架运行出错: {str(e)}")
        await framework._safe_shutdown()
        sys.exit(1)

if __name__ == "__main__":
    try:
        # 设置更详细的异常处理
        import signal
        
        def signal_handler(signum, frame):
            """信号处理"""
            print(f"\n🐱 接收到信号 {signum}，正在关闭...")
            sys.exit(0)
        
        # 注册信号处理
        signal.signal(signal.SIGINT, signal_handler)
        signal.signal(signal.SIGTERM, signal_handler)
     
        print("\n🐱 主程序启动...")    
        # 运行主程序
        parser = argparse.ArgumentParser(description="SenSu")
        parser.add_argument("--headless", action="store_true")
        args = parser.parse_args()
        asyncio.run(main(headless=args.headless))
        
    except KeyboardInterrupt:
        print("\n🐱 接收到键盘中断，关闭...")
        print("🐱 再见喵~")
        sys.exit(0)
    except SystemExit as e:
        # 优雅处理SystemExit
        exit_code = e.code if e.code is not None else 0
        if exit_code == 0:
            print("🐱 框架已关闭")
        else:
            print(f"🐱 框架退出，代码: {exit_code}")
        sys.exit(exit_code)
    except Exception as e:
        print(f"🐱 框架运行异常: {str(e)}")
        import traceback
        traceback.print_exc()
        sys.exit(1)
    finally:
        print("🐱 框架进程结束")