praisonai-code 0.0.1__py3-none-any.whl

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

@@ -0,0 +1,220 @@
+"""
+ACP health checks for PraisonAI Doctor.
+"""
+
+import asyncio
+import logging
+import os
+
+from ..models import CheckCategory, CheckResult, CheckStatus
+from ..registry import register_check
+
+logger = logging.getLogger(__name__)
+
+
+@register_check(
+    id="acp_module",
+    title="ACP Module Available",
+    category=CheckCategory.TOOLS,
+    description="Check if ACP module is installed"
+)
+def check_acp_module(config=None) -> CheckResult:
+    """Check if ACP module is available."""
+    try:
+        import importlib.util
+        spec = importlib.util.find_spec("praisonai.acp")
+        
+        if spec is not None:
+            return CheckResult(
+                id="acp_module",
+                title="ACP Module Available",
+                category=CheckCategory.TOOLS,
+                status=CheckStatus.PASS,
+                message="ACP module is available",
+                metadata={"module": "praisonai.acp"}
+            )
+        else:
+            return CheckResult(
+                id="acp_module",
+                title="ACP Module Available",
+                category=CheckCategory.TOOLS,
+                status=CheckStatus.WARN,
+                message="ACP module not found",
+                remediation="ACP module should be part of praisonai package"
+            )
+    except Exception as e:
+        return CheckResult(
+            id="acp_module",
+            title="ACP Module Available",
+            category=CheckCategory.TOOLS,
+            status=CheckStatus.FAIL,
+            message=f"Error checking ACP module: {e}",
+            metadata={"error": str(e)}
+        )
+
+
+@register_check(
+    id="acp_sdk",
+    title="ACP SDK Available",
+    category=CheckCategory.TOOLS,
+    description="Check if agent-client-protocol SDK is installed"
+)
+def check_acp_sdk(config=None) -> CheckResult:
+    """Check if ACP SDK is available."""
+    try:
+        import importlib.util
+        spec = importlib.util.find_spec("acp")
+        
+        if spec is not None:
+            return CheckResult(
+                id="acp_sdk",
+                title="ACP SDK Available",
+                category=CheckCategory.TOOLS,
+                status=CheckStatus.PASS,
+                message="ACP SDK (agent-client-protocol) is installed",
+                metadata={"package": "agent-client-protocol"}
+            )
+        else:
+            return CheckResult(
+                id="acp_sdk",
+                title="ACP SDK Available",
+                category=CheckCategory.TOOLS,
+                status=CheckStatus.SKIP,
+                message="ACP SDK not installed (optional)",
+                remediation="Install with: pip install agent-client-protocol"
+            )
+    except Exception as e:
+        return CheckResult(
+            id="acp_sdk",
+            title="ACP SDK Available",
+            category=CheckCategory.TOOLS,
+            status=CheckStatus.FAIL,
+            message=f"Error checking ACP SDK: {e}",
+            metadata={"error": str(e)}
+        )
+
+
+@register_check(
+    id="acp_server",
+    title="ACP Server Import",
+    category=CheckCategory.TOOLS,
+    description="Check if ACP server can be imported"
+)
+def check_acp_server(config=None) -> CheckResult:
+    """Check if ACP server can be imported."""
+    try:
+        from praisonai.acp import ACPServer  # noqa: F401
+        
+        return CheckResult(
+            id="acp_server",
+            title="ACP Server Import",
+            category=CheckCategory.TOOLS,
+            status=CheckStatus.PASS,
+            message="ACP server can be imported",
+            metadata={"class": "ACPServer"}
+        )
+    except ImportError as e:
+        return CheckResult(
+            id="acp_server",
+            title="ACP Server Import",
+            category=CheckCategory.TOOLS,
+            status=CheckStatus.WARN,
+            message=f"ACP server import failed: {e}",
+            metadata={"error": str(e)}
+        )
+    except Exception as e:
+        return CheckResult(
+            id="acp_server",
+            title="ACP Server Import",
+            category=CheckCategory.TOOLS,
+            status=CheckStatus.FAIL,
+            message=f"Error importing ACP server: {e}",
+            metadata={"error": str(e)}
+        )
+
+
+@register_check(
+    id="acp_config",
+    title="ACP Configuration",
+    category=CheckCategory.CONFIG,
+    description="Check ACP configuration"
+)
+def check_acp_config(config=None) -> CheckResult:
+    """Check ACP configuration."""
+    acp_conf = {
+        "approval_mode": os.environ.get("PRAISONAI_APPROVAL_MODE", "manual"),
+        "allow_write": os.environ.get("PRAISONAI_ALLOW_WRITE", "false"),
+        "allow_shell": os.environ.get("PRAISONAI_ALLOW_SHELL", "false"),
+    }
+    
+    return CheckResult(
+        id="acp_config",
+        title="ACP Configuration",
+        category=CheckCategory.CONFIG,
+        status=CheckStatus.PASS,
+        message=f"ACP configured with approval_mode={acp_conf['approval_mode']}",
+        metadata=acp_conf
+    )
+
+
+@register_check(
+    id="acp_runtime",
+    title="ACP Runtime Check",
+    category=CheckCategory.TOOLS,
+    description="Check if ACP runtime can start",
+    requires_deep=True
+)
+def check_acp_runtime(config=None) -> CheckResult:
+    """Check if ACP runtime can start."""
+    try:
+        from praisonai.cli.features.interactive_runtime import create_runtime
+        
+        async def _check():
+            runtime = create_runtime(
+                workspace=".",
+                lsp=False,
+                acp=True
+            )
+            try:
+                await runtime.start()
+                ready = runtime.acp_ready
+                error = runtime._acp_state.error
+                return ready, error
+            finally:
+                await runtime.stop()
+        
+        ready, error = asyncio.run(_check())
+        
+        if ready:
+            return CheckResult(
+                id="acp_runtime",
+                title="ACP Runtime Check",
+                category=CheckCategory.TOOLS,
+                status=CheckStatus.PASS,
+                message="ACP runtime started successfully",
+                metadata={"ready": True}
+            )
+        else:
+            return CheckResult(
+                id="acp_runtime",
+                title="ACP Runtime Check",
+                category=CheckCategory.TOOLS,
+                status=CheckStatus.WARN,
+                message=f"ACP runtime failed to start: {error}",
+                metadata={"ready": False, "error": str(error)}
+            )
+            
+    except Exception as e:
+        return CheckResult(
+            id="acp_runtime",
+            title="ACP Runtime Check",
+            category=CheckCategory.TOOLS,
+            status=CheckStatus.FAIL,
+            message=f"ACP runtime check failed: {e}",
+            metadata={"error": str(e)}
+        )
+
+
+def register_acp_checks():
+    """Register all ACP checks."""
+    pass

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

@@ -0,0 +1,340 @@
+"""
+Bot-specific doctor checks for PraisonAI.
+
+Registers checks for bot tokens, config validation, and channel probes.
+"""
+
+from __future__ import annotations
+
+import os
+import time
+from typing import List
+
+from ..models import CheckResult, CheckStatus, CheckCategory, CheckSeverity, DoctorConfig
+from ..registry import register_check
+
+
+@register_check(
+    id="bot_tokens",
+    title="Bot Tokens",
+    description="Check bot token environment variables",
+    category=CheckCategory.BOTS,
+    severity=CheckSeverity.MEDIUM,
+)
+def check_bot_tokens(config: DoctorConfig) -> CheckResult:
+    """Check bot token environment variables."""
+    from praisonai.cli._paths import resolve_bot_config_path
+    config_path = getattr(config, 'config_file', None) or resolve_bot_config_path("bot.yaml")
+    token_vars = {
+        "TELEGRAM_BOT_TOKEN": "Telegram",
+        "DISCORD_BOT_TOKEN": "Discord",
+        "SLACK_BOT_TOKEN": "Slack",
+        "WHATSAPP_ACCESS_TOKEN": "WhatsApp",
+    }
+    found = []
+    for var, name in token_vars.items():
+        if os.environ.get(var):
+            found.append(name)
+
+    if found:
+        return CheckResult(
+            id="bot_tokens",
+            title="Bot Tokens",
+            category=CheckCategory.BOTS,
+            status=CheckStatus.PASS,
+            message=f"Found: {', '.join(found)}",
+        )
+    return CheckResult(
+        id="bot_tokens",
+        title="Bot Tokens",
+        category=CheckCategory.BOTS,
+        status=CheckStatus.WARN,
+        message="No bot tokens found in environment",
+        remediation="Set at least one: export TELEGRAM_BOT_TOKEN=your_token",
+    )
+
+
+@register_check(
+    id="bot_config",
+    title="Bot Config",
+    description="Check bot.yaml exists and is valid",
+    category=CheckCategory.BOTS,
+    severity=CheckSeverity.MEDIUM,
+)
+def check_bot_config(config: DoctorConfig) -> CheckResult:
+    """Check bot.yaml exists and is valid."""
+    start = time.time()
+    from praisonai.cli._paths import resolve_bot_config_path
+    config_path = getattr(config, 'config_file', None) or resolve_bot_config_path("bot.yaml")
+    if not os.path.exists(config_path):
+        return CheckResult(
+            id="bot_config",
+            title="Bot Config",
+            category=CheckCategory.BOTS,
+            status=CheckStatus.WARN,
+            message=f"{config_path} not found",
+            remediation="Run 'praisonai onboard' to create one",
+            duration_ms=(time.time() - start) * 1000,
+        )
+    try:
+        from praisonai.bots._config_schema import load_and_validate_bot_yaml
+        load_and_validate_bot_yaml(config_path)
+        return CheckResult(
+            id="bot_config",
+            title="Bot Config",
+            category=CheckCategory.BOTS,
+            status=CheckStatus.PASS,
+            message=f"{config_path} valid",
+            duration_ms=(time.time() - start) * 1000,
+        )
+    except Exception as e:
+        return CheckResult(
+            id="bot_config",
+            title="Bot Config",
+            category=CheckCategory.BOTS,
+            status=CheckStatus.FAIL,
+            message=f"Invalid: {str(e)[:200]}",
+            remediation="Fix errors in bot.yaml or run 'praisonai onboard'",
+            duration_ms=(time.time() - start) * 1000,
+        )
+
+
+@register_check(
+    id="bot_security",
+    title="Bot Security Config", 
+    description="Check bot security configuration for safe defaults",
+    category=CheckCategory.BOTS,
+    severity=CheckSeverity.HIGH,
+)
+def check_bot_security(config: DoctorConfig) -> CheckResult:
+    """Check bot security configuration for safe defaults."""
+    start = time.time()
+    from praisonai.cli._paths import resolve_bot_config_path
+    config_path = getattr(config, 'config_file', None) or resolve_bot_config_path("bot.yaml")
+    channel_warnings = []
+    global_warnings = []
+    
+    # Check if bot.yaml exists
+    if not os.path.exists(config_path):
+        return CheckResult(
+            id="bot_security",
+            title="Bot Security Config",
+            category=CheckCategory.BOTS,
+            status=CheckStatus.SKIP,
+            message=f"{config_path} not found - security check skipped",
+            duration_ms=(time.time() - start) * 1000,
+        )
+    
+    try:
+        from praisonai.bots._config_schema import load_and_validate_bot_yaml
+        config = load_and_validate_bot_yaml(config_path)
+        
+        # Check for risky configurations across channels
+        for channel_name, channel_config in config.channels.items():
+            # Check for missing allowlists in production-like setups
+            if not channel_config.allowlist and not channel_config.blocklist:
+                channel_warnings.append(f"{channel_name}: No allowlist/blocklist configured")
+            
+            # Check for overly permissive group policies
+            if channel_config.group_policy == "respond_all":
+                channel_warnings.append(f"{channel_name}: group_policy='respond_all' - consider 'mention_only' for security")
+        
+        # Check for missing gateway pairing settings 
+        gateway_secret = os.environ.get("PRAISONAI_GATEWAY_SECRET")
+        if not gateway_secret:
+            global_warnings.append("PRAISONAI_GATEWAY_SECRET not set - pairing codes will not persist across restarts")
+        
+        # Determine status
+        all_warnings = channel_warnings + global_warnings
+        if all_warnings:
+            channel_count = len(channel_warnings)
+            global_count = len(global_warnings)
+            
+            if channel_count > 0 and global_count > 0:
+                message = f"Security recommendations: {channel_count} channel(s) and {global_count} global setting(s) could be improved"
+            elif channel_count > 0:
+                message = f"Security recommendations: {channel_count} channel(s) could use stricter defaults"
+            else:
+                message = f"Security recommendations: {global_count} global setting(s) could be improved"
+            
+            return CheckResult(
+                id="bot_security",
+                title="Bot Security Config",
+                category=CheckCategory.BOTS,
+                status=CheckStatus.WARN,
+                message=message,
+                details='\n'.join(all_warnings),
+                remediation="Consider allowlists for DM security and 'mention_only' group policy. See security docs for safe defaults.",
+                duration_ms=(time.time() - start) * 1000,
+            )
+        else:
+            return CheckResult(
+                id="bot_security",
+                title="Bot Security Config",
+                category=CheckCategory.BOTS,
+                status=CheckStatus.PASS,
+                message="Security configuration looks good",
+                duration_ms=(time.time() - start) * 1000,
+            )
+            
+    except ValueError as e:
+        return CheckResult(
+            id="bot_security",
+            title="Bot Security Config",
+            category=CheckCategory.BOTS,
+            status=CheckStatus.FAIL,
+            message=f"Invalid bot security config: {str(e)[:100]}",
+            details=str(e)[:200],
+            remediation="Fix bot.yaml security settings and re-run doctor",
+            duration_ms=(time.time() - start) * 1000,
+        )
+    except Exception as e:
+        return CheckResult(
+            id="bot_security",
+            title="Bot Security Config",
+            category=CheckCategory.BOTS,
+            status=CheckStatus.ERROR,
+            message=f"Error checking security: {str(e)[:100]}",
+            remediation="Fix bot.yaml syntax errors first",
+            duration_ms=(time.time() - start) * 1000,
+        )
+
+
+@register_check(
+    id="multi_channel_tokens",
+    title="Multi-Channel Token Configuration", 
+    description="Check for duplicate tokens across channels and validate multi-channel setup",
+    category=CheckCategory.BOTS,
+    severity=CheckSeverity.MEDIUM,
+)
+def check_multi_channel_tokens(config: DoctorConfig) -> CheckResult:
+    """Check multi-channel token configuration for duplicates and naming conventions."""
+    start = time.time()
+    from praisonai.cli._paths import resolve_bot_config_path
+    config_path = getattr(config, 'config_file', None) or resolve_bot_config_path("bot.yaml")
+    
+    # Check if bot.yaml exists
+    if not os.path.exists(config_path):
+        return CheckResult(
+            id="multi_channel_tokens",
+            title="Multi-Channel Token Configuration",
+            category=CheckCategory.BOTS,
+            status=CheckStatus.SKIP,
+            message=f"{config_path} not found - multi-channel check skipped",
+            duration_ms=(time.time() - start) * 1000,
+        )
+    
+    try:
+        from praisonai.bots._config_schema import load_and_validate_bot_yaml
+        config_data = load_and_validate_bot_yaml(config_path)
+        
+        warnings = []
+        errors = []
+        
+        # Extract token environment variables from channels
+        channel_tokens = {}  # env_var -> [channel_keys_using_it]
+        channel_platforms = {}  # platform -> [channel_keys]
+        
+        for channel_name, channel_config in config_data.channels.items():
+            platform = channel_config.platform
+            token_ref = channel_config.token
+            
+            # Track platforms
+            if platform not in channel_platforms:
+                channel_platforms[platform] = []
+            channel_platforms[platform].append(channel_name)
+            
+            # Extract environment variable from token reference like ${TELEGRAM_BOT_TOKEN}
+            if token_ref and token_ref.startswith("${") and token_ref.endswith("}"):
+                env_var = token_ref[2:-1]  # Remove ${ and }
+                if env_var not in channel_tokens:
+                    channel_tokens[env_var] = []
+                channel_tokens[env_var].append(channel_name)
+        
+        # Check for duplicate token usage by env var reference
+        for env_var, channels in channel_tokens.items():
+            if len(channels) > 1:
+                errors.append(f"Token {env_var} is used by multiple channels: {', '.join(channels)}")
+
+        # Also check duplicate token usage by resolved token value
+        token_value_to_channels = {}  # token_value -> [channel_keys]
+        for env_var, channels in channel_tokens.items():
+            token_value = os.environ.get(env_var)
+            if token_value:
+                token_value_to_channels.setdefault(token_value, []).extend(channels)
+
+        for _, channels in token_value_to_channels.items():
+            unique_channels = sorted(set(channels))
+            if len(unique_channels) > 1:
+                errors.append(
+                    f"Same bot token value is used by multiple channels: {', '.join(unique_channels)}"
+                )
+        
+        # Check for multi-platform channels with good naming conventions
+        for platform, channels in channel_platforms.items():
+            if len(channels) > 1:
+                # Multiple channels on same platform - check naming convention
+                for channel_name in channels:
+                    channel_config = config_data.channels[channel_name]
+                    token_ref = channel_config.token
+                    if token_ref and token_ref.startswith("${") and token_ref.endswith("}"):
+                        env_var = token_ref[2:-1]
+                        
+                        # Check if follows naming convention: PLATFORM_ROLE_BOT_TOKEN
+                        expected_pattern = f"{platform.upper()}_"
+                        if not env_var.startswith(expected_pattern) or not env_var.endswith("_BOT_TOKEN"):
+                            warnings.append(f"Channel '{channel_name}' token '{env_var}' doesn't follow naming convention '{platform.upper()}_<ROLE>_BOT_TOKEN'")
+        
+        # Check for missing tokens
+        missing_tokens = []
+        for env_var in channel_tokens.keys():
+            if not os.environ.get(env_var):
+                missing_tokens.append(env_var)
+        
+        # Determine status
+        if errors:
+            return CheckResult(
+                id="multi_channel_tokens",
+                title="Multi-Channel Token Configuration",
+                category=CheckCategory.BOTS,
+                status=CheckStatus.FAIL,
+                message=f"Token configuration errors: {len(errors)} duplicate(s) found",
+                details='\n'.join(errors + warnings),
+                remediation="Each channel must have a unique bot token. Create separate bots in @BotFather and use unique environment variables.",
+                duration_ms=(time.time() - start) * 1000,
+            )
+        elif warnings or missing_tokens:
+            all_issues = warnings + [f"Missing token: {token}" for token in missing_tokens]
+            return CheckResult(
+                id="multi_channel_tokens",
+                title="Multi-Channel Token Configuration",
+                category=CheckCategory.BOTS,
+                status=CheckStatus.WARN,
+                message=f"Multi-channel setup with {len(all_issues)} recommendation(s)",
+                details='\n'.join(all_issues),
+                remediation="Consider following the naming convention PLATFORM_ROLE_BOT_TOKEN for clarity.",
+                duration_ms=(time.time() - start) * 1000,
+            )
+        else:
+            channel_count = sum(len(channels) for channels in channel_platforms.values())
+            return CheckResult(
+                id="multi_channel_tokens",
+                title="Multi-Channel Token Configuration",
+                category=CheckCategory.BOTS,
+                status=CheckStatus.PASS,
+                message=f"Multi-channel configuration looks good ({channel_count} channels)",
+                duration_ms=(time.time() - start) * 1000,
+            )
+            
+    except Exception as e:
+        return CheckResult(
+            id="multi_channel_tokens",
+            title="Multi-Channel Token Configuration",
+            category=CheckCategory.BOTS,
+            status=CheckStatus.ERROR,
+            message=f"Error checking multi-channel config: {str(e)[:100]}",
+            remediation="Fix bot.yaml syntax errors first",
+            duration_ms=(time.time() - start) * 1000,
+        )
+
+