praisonai-code 0.0.1__py3-none-any.whl

praisonai_code/cli/features/doctor/checks/gateway_checks.py

@@ -0,0 +1,387 @@
+"""
+Gateway-specific doctor checks for PraisonAI.
+
+Validates gateway/bot configuration, performs migrations, and checks security.
+"""
+
+from __future__ import annotations
+
+import os
+import time
+from typing import List, Optional
+
+from ..models import CheckResult, CheckStatus, CheckCategory, CheckSeverity, DoctorConfig
+from ..registry import register_check
+
+
+@register_check(
+    id="gateway_config_validation",
+    title="Gateway Config Validation",
+    description="Validate gateway/bot configuration files",
+    category=CheckCategory.BOTS,
+    severity=CheckSeverity.HIGH,
+)
+def check_gateway_config_validation(config: DoctorConfig) -> CheckResult:
+    """Validate gateway/bot configuration using canonical schema."""
+    start = time.time()
+    
+    # Check multiple possible config locations
+    config_paths = []
+    if hasattr(config, 'config_file') and config.config_file:
+        config_paths.append(config.config_file)
+    
+    # Check common locations
+    from praisonai.cli._paths import resolve_bot_config_path
+    config_paths.extend([
+        resolve_bot_config_path("gateway.yaml"),
+        resolve_bot_config_path("bot.yaml"),
+        "gateway.yaml",
+        "bot.yaml",
+    ])
+    
+    # Find first existing config
+    config_path = None
+    for path in config_paths:
+        if os.path.exists(path):
+            config_path = path
+            break
+            
+    if not config_path:
+        return CheckResult(
+            id="gateway_config_validation",
+            title="Gateway Config Validation",
+            category=CheckCategory.BOTS,
+            status=CheckStatus.WARN,
+            message="No gateway/bot config found",
+            remediation="Run 'praisonai onboard' to create bot.yaml",
+            duration_ms=(time.time() - start) * 1000,
+        )
+        
+    try:
+        from praisonai.bots._config_schema import load_and_validate_gateway_yaml
+        validated_config = load_and_validate_gateway_yaml(config_path)
+        
+        channel_count = len(validated_config.channels)
+        agent_count = 1 if validated_config.agent else 0
+        if validated_config.agents:
+            agent_count = len(validated_config.agents)
+            
+        return CheckResult(
+            id="gateway_config_validation", 
+            title="Gateway Config Validation",
+            category=CheckCategory.BOTS,
+            status=CheckStatus.PASS,
+            message=f"{config_path} valid ({channel_count} channels, {agent_count} agents)",
+            duration_ms=(time.time() - start) * 1000,
+        )
+    except ValueError as e:
+        return CheckResult(
+            id="gateway_config_validation",
+            title="Gateway Config Validation",
+            category=CheckCategory.BOTS,
+            status=CheckStatus.FAIL,
+            message=f"Invalid config: {str(e)[:100]}",
+            details=str(e),
+            remediation="Fix validation errors in your config file",
+            duration_ms=(time.time() - start) * 1000,
+        )
+    except Exception as e:
+        return CheckResult(
+            id="gateway_config_validation",
+            title="Gateway Config Validation",
+            category=CheckCategory.BOTS,
+            status=CheckStatus.ERROR,
+            message=f"Error validating config: {str(e)[:100]}",
+            remediation="Check config file syntax",
+            duration_ms=(time.time() - start) * 1000,
+        )
+
+
+@register_check(
+    id="gateway_security",
+    title="Gateway Security Settings",
+    description="Check gateway security configuration",
+    category=CheckCategory.BOTS,
+    severity=CheckSeverity.HIGH,
+)
+def check_gateway_security(config: DoctorConfig) -> CheckResult:
+    """Check gateway security settings for safe defaults."""
+    start = time.time()
+    
+    # Find config file
+    from praisonai.cli._paths import resolve_bot_config_path
+    config_path = None
+    for path in [resolve_bot_config_path("gateway.yaml"), resolve_bot_config_path("bot.yaml"), "gateway.yaml", "bot.yaml"]:
+        if os.path.exists(path):
+            config_path = path
+            break
+            
+    if not config_path:
+        return CheckResult(
+            id="gateway_security",
+            title="Gateway Security Settings",
+            category=CheckCategory.BOTS,
+            status=CheckStatus.SKIP,
+            message="No config found - security check skipped",
+            duration_ms=(time.time() - start) * 1000,
+        )
+        
+    try:
+        from praisonai.bots._config_schema import load_and_validate_gateway_yaml
+        validated_config = load_and_validate_gateway_yaml(config_path)
+        
+        security_issues = []
+        warnings = []
+        
+        for channel_name, channel in validated_config.channels.items():
+            # Check for open allowlists (CRITICAL)
+            if not channel.allowed_users and not channel.allowlist and not channel.blocklist:
+                security_issues.append(
+                    f"{channel_name}: No user restrictions - bot responds to EVERYONE!"
+                )
+                
+            # Check for overly permissive group policies (WARNING)
+            if channel.group_policy == "respond_all":
+                warnings.append(
+                    f"{channel_name}: Using 'respond_all' - consider 'mention_only'"
+                )
+                
+            # Check for missing tokens
+            if not channel.token:
+                security_issues.append(
+                    f"{channel_name}: No token configured"
+                )
+                
+        # Check gateway auth token
+        if not os.environ.get("GATEWAY_AUTH_TOKEN"):
+            warnings.append("GATEWAY_AUTH_TOKEN not set - gateway has no authentication")
+            
+        if security_issues:
+            return CheckResult(
+                id="gateway_security",
+                title="Gateway Security Settings",
+                category=CheckCategory.BOTS,
+                status=CheckStatus.FAIL,
+                message=f"Critical security issues: {len(security_issues)} problem(s)",
+                details="\n".join(security_issues + warnings),
+                remediation="Add allowed_users to restrict bot access. Use 'mention_only' for groups.",
+                duration_ms=(time.time() - start) * 1000,
+            )
+        elif warnings:
+            return CheckResult(
+                id="gateway_security",
+                title="Gateway Security Settings",
+                category=CheckCategory.BOTS,
+                status=CheckStatus.WARN,
+                message=f"Security recommendations: {len(warnings)} improvement(s)",
+                details="\n".join(warnings),
+                remediation="Consider stricter security settings",
+                duration_ms=(time.time() - start) * 1000,
+            )
+        else:
+            return CheckResult(
+                id="gateway_security",
+                title="Gateway Security Settings",
+                category=CheckCategory.BOTS,
+                status=CheckStatus.PASS,
+                message="Security configuration looks good",
+                duration_ms=(time.time() - start) * 1000,
+            )
+            
+    except Exception as e:
+        return CheckResult(
+            id="gateway_security",
+            title="Gateway Security Settings",
+            category=CheckCategory.BOTS,
+            status=CheckStatus.ERROR,
+            message=f"Error checking security: {str(e)[:100]}",
+            remediation="Fix config errors first",
+            duration_ms=(time.time() - start) * 1000,
+        )
+
+
+@register_check(
+    id="gateway_config_migration",
+    title="Gateway Config Migration",
+    description="Check if config needs migration to canonical format",
+    category=CheckCategory.BOTS,
+    severity=CheckSeverity.MEDIUM,
+)
+def check_gateway_config_migration(config: DoctorConfig) -> CheckResult:
+    """Check if configuration needs migration to canonical format."""
+    start = time.time()
+    
+    # Find config file
+    from praisonai.cli._paths import resolve_bot_config_path
+    config_path = None
+    for path in [resolve_bot_config_path("gateway.yaml"), resolve_bot_config_path("bot.yaml"), "gateway.yaml", "bot.yaml"]:
+        if os.path.exists(path):
+            config_path = path
+            break
+            
+    if not config_path:
+        return CheckResult(
+            id="gateway_config_migration",
+            title="Gateway Config Migration",
+            category=CheckCategory.BOTS,
+            status=CheckStatus.SKIP,
+            message="No config found - migration check skipped",
+            duration_ms=(time.time() - start) * 1000,
+        )
+        
+    try:
+        import yaml
+        import copy
+        with open(config_path) as f:
+            raw = yaml.safe_load(f) or {}
+        
+        # Deep copy to preserve original for comparison
+        original = copy.deepcopy(raw)
+            
+        from praisonai.bots._config_schema import migrate_legacy_config
+        migrated = migrate_legacy_config(copy.deepcopy(original))
+        
+        # Check if migration changed anything
+        if migrated != original:
+            changes = []
+            
+            # Detect specific migrations
+            if "platform" in raw and "token" in raw and "channels" not in raw:
+                changes.append("Single-bot format can be migrated to multi-channel format")
+                
+            if "platforms" in raw and "channels" not in raw:
+                changes.append("BotOS platforms format can be migrated to channels format")
+                
+            # Check for string allowed_users
+            if "channels" in raw:
+                for channel_name, channel in raw["channels"].items():
+                    if isinstance(channel.get("allowed_users"), str):
+                        changes.append(f"{channel_name}: allowed_users string → list migration available")
+                        
+            return CheckResult(
+                id="gateway_config_migration",
+                title="Gateway Config Migration",
+                category=CheckCategory.BOTS,
+                status=CheckStatus.WARN,
+                message=f"Config can be migrated: {len(changes)} change(s)",
+                details="\n".join(changes),
+                remediation="Run 'praisonai gateway migrate' to update config to latest format",
+                duration_ms=(time.time() - start) * 1000,
+            )
+        else:
+            return CheckResult(
+                id="gateway_config_migration",
+                title="Gateway Config Migration",
+                category=CheckCategory.BOTS,
+                status=CheckStatus.PASS,
+                message="Config uses current format",
+                duration_ms=(time.time() - start) * 1000,
+            )
+            
+    except Exception as e:
+        return CheckResult(
+            id="gateway_config_migration",
+            title="Gateway Config Migration",
+            category=CheckCategory.BOTS,
+            status=CheckStatus.ERROR,
+            message=f"Error checking migration: {str(e)[:100]}",
+            remediation="Fix config syntax errors first",
+            duration_ms=(time.time() - start) * 1000,
+        )
+
+
+@register_check(
+    id="gateway_env_substitution",
+    title="Gateway Environment Variables",
+    description="Check environment variable substitution in config",
+    category=CheckCategory.BOTS,
+    severity=CheckSeverity.MEDIUM,
+)
+def check_gateway_env_substitution(config: DoctorConfig) -> CheckResult:
+    """Check that environment variables referenced in config are set."""
+    start = time.time()
+    
+    # Find config file
+    from praisonai.cli._paths import resolve_bot_config_path
+    config_path = None
+    for path in [resolve_bot_config_path("gateway.yaml"), resolve_bot_config_path("bot.yaml"), "gateway.yaml", "bot.yaml"]:
+        if os.path.exists(path):
+            config_path = path
+            break
+            
+    if not config_path:
+        return CheckResult(
+            id="gateway_env_substitution",
+            title="Gateway Environment Variables",
+            category=CheckCategory.BOTS,
+            status=CheckStatus.SKIP,
+            message="No config found - env check skipped",
+            duration_ms=(time.time() - start) * 1000,
+        )
+        
+    try:
+        import re
+        from praisonai.cli.utils.env_utils import load_env_file
+        
+        # Load .env file first to ensure all env vars are available
+        try:
+            load_env_file()
+        except:
+            pass  # .env file might not exist, continue anyway
+        
+        with open(config_path) as f:
+            content = f.read()
+            
+        # Find all ${VAR} references
+        env_refs = re.findall(r'\$\{([^}]+)\}', content)
+        
+        if not env_refs:
+            return CheckResult(
+                id="gateway_env_substitution",
+                title="Gateway Environment Variables",
+                category=CheckCategory.BOTS,
+                status=CheckStatus.PASS,
+                message="No environment variables referenced",
+                duration_ms=(time.time() - start) * 1000,
+            )
+            
+        # Check which are set
+        missing = []
+        found = []
+        for env_var in sorted(set(env_refs)):
+            if env_var in os.environ:
+                found.append(env_var)
+            else:
+                missing.append(env_var)
+                
+        if missing:
+            return CheckResult(
+                id="gateway_env_substitution",
+                title="Gateway Environment Variables",
+                category=CheckCategory.BOTS,
+                status=CheckStatus.FAIL,
+                message=f"Missing environment variables: {len(missing)}",
+                details=f"Not set: {', '.join(missing)}",
+                remediation=f"Set missing variables: {' '.join(f'export {v}=...' for v in missing)}",
+                duration_ms=(time.time() - start) * 1000,
+            )
+        else:
+            return CheckResult(
+                id="gateway_env_substitution",
+                title="Gateway Environment Variables",
+                category=CheckCategory.BOTS,
+                status=CheckStatus.PASS,
+                message=f"All {len(found)} environment variables are set",
+                duration_ms=(time.time() - start) * 1000,
+            )
+            
+    except Exception as e:
+        return CheckResult(
+            id="gateway_env_substitution",
+            title="Gateway Environment Variables",
+            category=CheckCategory.BOTS,
+            status=CheckStatus.ERROR,
+            message=f"Error checking env vars: {str(e)[:100]}",
+            remediation="Check config file access",
+            duration_ms=(time.time() - start) * 1000,
+        )

praisonai_code/cli/features/doctor/checks/lsp_checks.py

@@ -0,0 +1,231 @@
+"""
+LSP health checks for PraisonAI Doctor.
+"""
+
+import asyncio
+import logging
+import shutil
+
+from ..models import CheckCategory, CheckResult, CheckStatus
+from ..registry import register_check
+
+logger = logging.getLogger(__name__)
+
+
+@register_check(
+    id="lsp_module",
+    title="LSP Module Available",
+    category=CheckCategory.TOOLS,
+    description="Check if LSP module is installed"
+)
+def check_lsp_module(config=None) -> CheckResult:
+    """Check if LSP module is available."""
+    try:
+        import importlib.util
+        spec = importlib.util.find_spec("praisonaiagents.lsp")
+        
+        if spec is not None:
+            return CheckResult(
+                id="lsp_module",
+                title="LSP Module Available",
+                category=CheckCategory.TOOLS,
+                status=CheckStatus.PASS,
+                message="LSP module is available",
+                metadata={"module": "praisonaiagents.lsp"}
+            )
+        else:
+            return CheckResult(
+                id="lsp_module",
+                title="LSP Module Available",
+                category=CheckCategory.TOOLS,
+                status=CheckStatus.WARN,
+                message="LSP module not found",
+                remediation="Install praisonaiagents with LSP support"
+            )
+    except Exception as e:
+        return CheckResult(
+            id="lsp_module",
+            title="LSP Module Available",
+            category=CheckCategory.TOOLS,
+            status=CheckStatus.FAIL,
+            message=f"Error checking LSP module: {e}",
+            metadata={"error": str(e)}
+        )
+
+
+@register_check(
+    id="lsp_client",
+    title="LSP Client Import",
+    category=CheckCategory.TOOLS,
+    description="Check if LSP client can be imported"
+)
+def check_lsp_client(config=None) -> CheckResult:
+    """Check if LSP client can be imported."""
+    try:
+        from praisonaiagents.lsp import LSPClient  # noqa: F401
+        
+        return CheckResult(
+            id="lsp_client",
+            title="LSP Client Import",
+            category=CheckCategory.TOOLS,
+            status=CheckStatus.PASS,
+            message="LSP client can be imported",
+            metadata={"class": "LSPClient"}
+        )
+    except ImportError as e:
+        return CheckResult(
+            id="lsp_client",
+            title="LSP Client Import",
+            category=CheckCategory.TOOLS,
+            status=CheckStatus.WARN,
+            message=f"LSP client import failed: {e}",
+            metadata={"error": str(e)}
+        )
+    except Exception as e:
+        return CheckResult(
+            id="lsp_client",
+            title="LSP Client Import",
+            category=CheckCategory.TOOLS,
+            status=CheckStatus.FAIL,
+            message=f"Error importing LSP client: {e}",
+            metadata={"error": str(e)}
+        )
+
+
+@register_check(
+    id="lsp_server_python",
+    title="Python LSP Server",
+    category=CheckCategory.TOOLS,
+    description="Check if Python language server is available"
+)
+def check_lsp_server_python(config=None) -> CheckResult:
+    """Check if Python language server is available."""
+    servers = [
+        ("pyright-langserver", "pyright"),
+        ("pylsp", "python-lsp-server"),
+        ("pyls", "python-language-server"),
+    ]
+    
+    found = []
+    for cmd, package in servers:
+        if shutil.which(cmd):
+            found.append({"command": cmd, "package": package})
+    
+    if found:
+        return CheckResult(
+            id="lsp_server_python",
+            title="Python LSP Server",
+            category=CheckCategory.TOOLS,
+            status=CheckStatus.PASS,
+            message=f"Python LSP server available: {found[0]['command']}",
+            metadata={"servers": found}
+        )
+    else:
+        return CheckResult(
+            id="lsp_server_python",
+            title="Python LSP Server",
+            category=CheckCategory.TOOLS,
+            status=CheckStatus.WARN,
+            message="No Python LSP server found",
+            remediation="Install with: npm install -g pyright OR pip install python-lsp-server"
+        )
+
+
+@register_check(
+    id="lsp_server_typescript",
+    title="TypeScript LSP Server",
+    category=CheckCategory.TOOLS,
+    description="Check if TypeScript language server is available"
+)
+def check_lsp_server_typescript(config=None) -> CheckResult:
+    """Check if TypeScript language server is available."""
+    if shutil.which("typescript-language-server"):
+        return CheckResult(
+            id="lsp_server_typescript",
+            title="TypeScript LSP Server",
+            category=CheckCategory.TOOLS,
+            status=CheckStatus.PASS,
+            message="TypeScript LSP server available",
+            metadata={"command": "typescript-language-server"}
+        )
+    elif shutil.which("tsserver"):
+        return CheckResult(
+            id="lsp_server_typescript",
+            title="TypeScript LSP Server",
+            category=CheckCategory.TOOLS,
+            status=CheckStatus.PASS,
+            message="TypeScript server available (tsserver)",
+            metadata={"command": "tsserver"}
+        )
+    else:
+        return CheckResult(
+            id="lsp_server_typescript",
+            title="TypeScript LSP Server",
+            category=CheckCategory.TOOLS,
+            status=CheckStatus.SKIP,
+            message="TypeScript LSP server not found (optional)",
+            remediation="Install with: npm install -g typescript-language-server typescript"
+        )
+
+
+@register_check(
+    id="lsp_runtime",
+    title="LSP Runtime Check",
+    category=CheckCategory.TOOLS,
+    description="Check if LSP runtime can start",
+    requires_deep=True
+)
+def check_lsp_runtime(config=None) -> CheckResult:
+    """Check if LSP runtime can start."""
+    try:
+        from praisonai.cli.features.interactive_runtime import create_runtime
+        
+        async def _check():
+            runtime = create_runtime(
+                workspace=".",
+                lsp=True,
+                acp=False
+            )
+            try:
+                await runtime.start()
+                ready = runtime.lsp_ready
+                error = runtime._lsp_state.error
+                return ready, error
+            finally:
+                await runtime.stop()
+        
+        ready, error = asyncio.run(_check())
+        
+        if ready:
+            return CheckResult(
+                id="lsp_runtime",
+                title="LSP Runtime Check",
+                category=CheckCategory.TOOLS,
+                status=CheckStatus.PASS,
+                message="LSP runtime started successfully",
+                metadata={"ready": True}
+            )
+        else:
+            return CheckResult(
+                id="lsp_runtime",
+                title="LSP Runtime Check",
+                category=CheckCategory.TOOLS,
+                status=CheckStatus.WARN,
+                message=f"LSP runtime failed to start: {error}",
+                metadata={"ready": False, "error": str(error)}
+            )
+            
+    except Exception as e:
+        return CheckResult(
+            id="lsp_runtime",
+            title="LSP Runtime Check",
+            category=CheckCategory.TOOLS,
+            status=CheckStatus.FAIL,
+            message=f"LSP runtime check failed: {e}",
+            metadata={"error": str(e)}
+        )
+
+
+def register_lsp_checks():
+    """Register all LSP checks."""
+    pass