ai-parrot 0.17.2__cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

parrot/scheduler/models.py

@@ -0,0 +1,60 @@
+from typing import Any, Dict, Optional, Callable, List
+from datetime import datetime
+import uuid
+from asyncdb.models import Model, Field
+
+
+class AgentSchedule(Model):
+    """
+    Database model for storing agent schedules.
+
+    SQL Table Creation:
+    CREATE TABLE IF NOT EXISTS navigator.agents_scheduler (
+        schedule_id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+        agent_id VARCHAR NOT NULL,
+        agent_name VARCHAR NOT NULL,
+        prompt TEXT,
+        method_name VARCHAR,
+        schedule_type VARCHAR NOT NULL,
+        schedule_config JSONB NOT NULL,
+        enabled BOOLEAN DEFAULT TRUE,
+        created_by INTEGER,
+        created_email VARCHAR,
+        created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        last_run TIMESTAMP WITH TIME ZONE,
+        next_run TIMESTAMP WITH TIME ZONE,
+        run_count INTEGER DEFAULT 0,
+        metadata JSONB DEFAULT '{}'::JSONB,
+        is_crew BOOLEAN DEFAULT FALSE,
+        send_result JSONB DEFAULT '{}'::JSONB
+    );
+
+    CREATE INDEX idx_agents_scheduler_enabled ON navigator.agents_scheduler(enabled);
+    CREATE INDEX idx_agents_scheduler_agent ON navigator.agents_scheduler(agent_name);
+    """
+    schedule_id: uuid.UUID = Field(primary_key=True, default_factory=uuid.uuid4)
+    agent_id: str = Field(required=True)
+    agent_name: str = Field(required=True)
+    prompt: Optional[str] = Field(required=False)
+    method_name: Optional[str] = Field(required=False)
+    schedule_type: str = Field(required=True)
+    schedule_config: dict = Field(required=True, default_factory=dict)
+    enabled: bool = Field(required=False, default=True)
+    created_by: Optional[int] = Field(required=False)
+    created_email: Optional[str] = Field(required=False)
+    created_at: datetime = Field(required=False, default_factory=datetime.now)
+    updated_at: datetime = Field(required=False, default_factory=datetime.now)
+    last_run: Optional[datetime] = Field(required=False)
+    next_run: Optional[datetime] = Field(required=False)
+    run_count: int = Field(required=False, default=0)
+    metadata: dict = Field(required=False, default_factory=dict)
+    is_crew: bool = Field(required=False, default=False)
+    send_result: dict = Field(required=False, default_factory=dict)
+
+    class Meta:
+        driver = 'pg'
+        name = "agents_scheduler"
+        schema = "navigator"
+        strict = True
+        frozen = False

parrot/security/__init__.py

@@ -0,0 +1,16 @@
+"""
+Security utilities for AI-Parrot.
+"""
+from .prompt_injection import (
+    PromptInjectionDetector,
+    SecurityEventLogger,
+    ThreatLevel,
+    PromptInjectionException
+)
+
+__all__ = [
+    'PromptInjectionDetector',
+    'SecurityEventLogger',
+    'ThreatLevel',
+    'PromptInjectionException'
+]

parrot/security/prompt_injection.py

@@ -0,0 +1,268 @@
+"""
+Prompt Injection Detection and Protection.
+"""
+from typing import Optional, Dict, Any, List, Tuple
+from enum import Enum
+import re
+from datetime import datetime, timezone
+from navconfig.logging import logging
+
+
+class ThreatLevel(Enum):
+    """Severity levels for detected threats."""
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+    CRITICAL = "critical"
+
+
+class PromptInjectionException(Exception):
+    """Raised when a critical prompt injection is detected in strict mode."""
+    def __init__(self, message: str, threats: List[Dict], original_input: str):
+        super().__init__(message)
+        self.threats = threats
+        self.original_input = original_input
+
+
+class PromptInjectionDetector:
+    """
+    Detects and mitigates prompt injection attempts in user questions.
+    """
+
+    # CRITICAL: Direct instruction override attempts
+    CRITICAL_PATTERNS = [
+        (
+            re.compile(r'ignore\s+(all\s+)?(previous|above|prior)\s+instructions?', re.IGNORECASE),
+            "Direct instruction override"
+        ),
+        (
+            re.compile(r'forget\s+(everything|all|your\s+(instructions?|rules?|prompt))', re.IGNORECASE),
+            "Memory wipe attempt"
+        ),
+        (
+            re.compile(r'you\s+are\s+now\s+(a|an|no\s+longer)', re.IGNORECASE),
+            "Role hijacking"
+        ),
+        (
+            re.compile(r'disregard\s+(all\s+)?(previous|above|prior|your)', re.IGNORECASE),
+            "Disregard command"
+        ),
+    ]
+
+    # HIGH: System impersonation
+    HIGH_PATTERNS = [
+        (
+            re.compile(r'system\s*:\s*', re.IGNORECASE),
+            "System role impersonation"
+        ),
+        (
+            re.compile(r'<\s*/?system\s*>', re.IGNORECASE),
+            "System tag injection"
+        ),
+        (
+            re.compile(r'\[SYSTEM\]|\(SYSTEM\)|【SYSTEM】', re.IGNORECASE),
+            "System marker injection"
+        ),
+        (
+            re.compile(r'new\s+instructions?:\s*', re.IGNORECASE),
+            "Instruction replacement"
+        ),
+        (
+            re.compile(r'assistant\s*:\s*ignore', re.IGNORECASE),
+            "Assistant role injection"
+        ),
+    ]
+
+    # MEDIUM: Prompt extraction attempts
+    MEDIUM_PATTERNS = [
+        (
+            re.compile(r'(reveal|show|print|display|output)\s+(your\s+)?(prompt|instructions|system\s+message)', re.IGNORECASE),
+            "Prompt extraction attempt"
+        ),
+        (
+            re.compile(r'what\s+(is|are)\s+your\s+(original\s+)?(instructions?|prompt|rules?)', re.IGNORECASE),
+            "Instruction disclosure request"
+        ),
+    ]
+
+    def __init__(self, logger: Optional[logging.Logger] = None):
+        self.logger = logger or logging.getLogger(__name__)
+
+    def detect_threats(self, text: str) -> List[Dict[str, Any]]:
+        """
+        Scan text for prompt injection patterns.
+
+        Returns:
+            List of detected threats with details
+        """
+        if not text or not isinstance(text, str):
+            return []
+
+        threats = []
+
+        # Check CRITICAL patterns
+        for pattern, description in self.CRITICAL_PATTERNS:
+            if match := pattern.search(text):
+                threats.append({
+                    'level': ThreatLevel.CRITICAL,
+                    'pattern': pattern.pattern,
+                    'description': description,
+                    'matched_text': match.group(0),
+                    'position': match.span()
+                })
+
+        # Check HIGH patterns
+        for pattern, description in self.HIGH_PATTERNS:
+            if match := pattern.search(text):
+                threats.append({
+                    'level': ThreatLevel.HIGH,
+                    'pattern': pattern.pattern,
+                    'description': description,
+                    'matched_text': match.group(0),
+                    'position': match.span()
+                })
+
+        # Check MEDIUM patterns
+        for pattern, description in self.MEDIUM_PATTERNS:
+            if match := pattern.search(text):
+                threats.append({
+                    'level': ThreatLevel.MEDIUM,
+                    'pattern': pattern.pattern,
+                    'description': description,
+                    'matched_text': match.group(0),
+                    'position': match.span()
+                })
+
+        return threats
+
+    def sanitize(
+        self,
+        text: str,
+        strict: bool = True,
+        replacement: str = "[FILTERED_CONTENT]"
+    ) -> Tuple[str, List[Dict[str, Any]]]:
+        """
+        Sanitize text by replacing detected patterns.
+
+        Args:
+            text: Input text to sanitize
+            strict: If True, replace patterns; if False, only detect
+            replacement: Text to use for replacements
+
+        Returns:
+            Tuple of (sanitized_text, detected_threats)
+        """
+        threats = self.detect_threats(text)
+
+        if not strict or not threats:
+            return text, threats
+
+        sanitized = text
+
+        # In strict mode, replace CRITICAL and HIGH patterns
+        for pattern, _ in self.CRITICAL_PATTERNS + self.HIGH_PATTERNS:
+            sanitized = pattern.sub(replacement, sanitized)
+
+        return sanitized, threats
+
+
+class SecurityEventLogger:
+    """
+    Logs security events with session tracking.
+    """
+
+    def __init__(self, db_pool=None, logger: Optional[logging.Logger] = None):
+        self.db_pool = db_pool
+        self.logger = logger or logging.getLogger(__name__)
+
+    async def log_injection_attempt(
+        self,
+        user_id: str,
+        session_id: str,
+        chatbot_id: str,
+        threats: List[Dict[str, Any]],
+        original_input: str,
+        sanitized_input: str,
+        metadata: Optional[Dict[str, Any]] = None
+    ):
+        """
+        Log a detected prompt injection attempt.
+        """
+        max_severity = max(
+            (t['level'] for t in threats),
+            default=ThreatLevel.LOW
+        )
+
+        # Always log to application logger
+        for threat in threats:
+            self.logger.warning(
+                f"🔒 SECURITY: Prompt injection detected | "
+                f"Severity: {threat['level'].value.upper()} | "
+                f"User: {user_id} | Session: {session_id} | "
+                f"Bot: {chatbot_id} | "
+                f"Type: {threat['description']} | "
+                f"Pattern: '{threat['matched_text']}'"
+            )
+
+        # Log to database if pool available
+        if self.db_pool:
+            await self._log_to_database(
+                user_id=user_id,
+                session_id=session_id,
+                chatbot_id=chatbot_id,
+                threats=threats,
+                original_input=original_input,
+                sanitized_input=sanitized_input,
+                max_severity=max_severity,
+                metadata=metadata or {}
+            )
+
+    async def _log_to_database(
+        self,
+        user_id: str,
+        session_id: str,
+        chatbot_id: str,
+        threats: List[Dict[str, Any]],
+        original_input: str,
+        sanitized_input: str,
+        max_severity: ThreatLevel,
+        metadata: Dict[str, Any]
+    ):
+        """Store security event in database."""
+        try:
+            query = """
+            INSERT INTO navigator.security_events (
+                event_type,
+                user_id,
+                session_id,
+                chatbot_id,
+                severity,
+                threat_details,
+                original_input,
+                sanitized_input,
+                metadata,
+                created_at
+            ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+            """
+
+            async with await self.db_pool.acquire() as conn:
+                await conn.execute(
+                    query,
+                    'prompt_injection',
+                    user_id,
+                    session_id,
+                    chatbot_id,
+                    max_severity.value,
+                    threats,  # PostgreSQL JSONB
+                    original_input[:2000],  # Truncate for storage
+                    sanitized_input[:2000],
+                    metadata,
+                    datetime.now(timezone.utc),
+                )
+
+            self.logger.info(
+                f"Security event logged to database for user {user_id}"
+            )
+
+        except Exception as e:
+            self.logger.error(f"Failed to log security event to database: {e}")

parrot/security/security_events.sql

@@ -0,0 +1,25 @@
+-- Security events tracking table
+CREATE TABLE IF NOT EXISTS security_events (
+    event_id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    event_type VARCHAR(50) NOT NULL,
+    user_id VARCHAR(255) NOT NULL,
+    session_id VARCHAR(255) NOT NULL,
+    chatbot_id VARCHAR(255),
+    severity VARCHAR(20) NOT NULL,
+    threat_details JSONB NOT NULL,
+    original_input TEXT,
+    sanitized_input TEXT,
+    metadata JSONB DEFAULT '{}',
+    created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW()
+);
+
+-- Indexes for security monitoring
+CREATE INDEX idx_security_events_user_id ON security_events(user_id);
+CREATE INDEX idx_security_events_session_id ON security_events(session_id);
+CREATE INDEX idx_security_events_severity ON security_events(severity);
+CREATE INDEX idx_security_events_created_at ON security_events(created_at DESC);
+CREATE INDEX idx_security_events_chatbot ON security_events(chatbot_id);
+
+-- Index for monitoring critical/high severity events
+CREATE INDEX idx_security_events_high_severity ON security_events(severity, created_at DESC)
+WHERE severity IN ('critical', 'high');

parrot/services/__init__.py

@@ -0,0 +1 @@
+"""Parrot service helpers."""

parrot/services/mcp/__init__.py

@@ -0,0 +1,8 @@
+from .config import TransportConfig
+from .server import ParrotMCPServer  # noqa: F401
+
+
+__all__ = (
+    "ParrotMCPServer",
+    "TransportConfig",
+)

parrot/services/mcp/config.py

@@ -0,0 +1,13 @@
+from typing import Optional
+from dataclasses import dataclass
+
+@dataclass
+class TransportConfig:
+    """Configuration for a single transport."""
+    transport: str  # "stdio" or "http" or "sse" or "unix"
+    enabled: bool = True
+    host: Optional[str] = None  # Only for HTTP
+    port: Optional[int] = None  # Only for HTTP
+    url: Optional[str] = None  # Only for HTTP/SSE transport
+    name_suffix: Optional[str] = None  # e.g., "local" or "remote"
+    socket_path: Optional[str] = None  # Only for UNIX socket transport

parrot/services/mcp/server.py

@@ -0,0 +1,295 @@
+"""Utilities for starting the MCP server inside the aiohttp application."""
+from __future__ import annotations
+from typing import Dict, List, Optional, Union
+import asyncio
+import contextlib
+import inspect
+from importlib import import_module
+from aiohttp import web
+from navconfig.logging import logging
+from ...conf import (
+    MCP_SERVER_DESCRIPTION,
+    MCP_SERVER_HOST,
+    MCP_SERVER_LOG_LEVEL,
+    MCP_SERVER_NAME,
+    MCP_SERVER_PORT,
+    MCP_SERVER_TRANSPORT,
+    MCP_STARTED_TOOLS,
+)
+from ...mcp.server import MCPServer, MCPServerConfig, HttpMCPServer, SseMCPServer
+from ...tools.abstract import AbstractTool
+from ...tools.toolkit import AbstractToolkit
+from .config import TransportConfig
+
+
+class ParrotMCPServer:
+    """Manage lifecycle of multiple MCP servers (multi-transport) attached to an aiohttp app."""
+
+    def __init__(
+        self,
+        *,
+        transports: Optional[Union[str, List[str], Dict[str, TransportConfig]]] = None,
+        host: Optional[str] = None,
+        port: Optional[int] = None,
+        tools: Optional[Dict[str, str]] = None,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        log_level: Optional[str] = None,
+        allow_anonymous: bool = True,
+    ) -> None:
+        self.name = name or MCP_SERVER_NAME
+        self.description = description or MCP_SERVER_DESCRIPTION
+        self.log_level = log_level or MCP_SERVER_LOG_LEVEL
+        self.tools_config = tools if isinstance(tools, dict) else MCP_STARTED_TOOLS
+        self.toolkit_instance = tools if isinstance(tools, AbstractToolkit) else None
+        self.allow_anonymous = allow_anonymous
+        # Parse transport configuration
+        self.transport_configs = self._parse_transports(
+            transports, host, port
+        )
+        # Multiple servers, one per transport
+        self.servers: Dict[str, MCPServer] = {}
+        self._server_tasks: Dict[str, asyncio.Task] = {}
+        self.logger = logging.getLogger("Parrot.MCPServer")
+        self.app: Optional[web.Application] = None
+
+        # Multiple servers, one per transport
+        self.servers: Dict[str, MCPServer] = {}
+        self._server_tasks: Dict[str, asyncio.Task] = {}
+
+    def _parse_transports(
+        self,
+        transports: Optional[Union[str, List[str], Dict[str, TransportConfig]]],
+        default_host: Optional[str],
+        default_port: Optional[int],
+    ) -> Dict[str, TransportConfig]:
+        """Parse transport configuration into normalized format."""
+        if transports is None:
+            # Default: HTTP only
+            transports = MCP_SERVER_TRANSPORT or "http"
+
+        configs = {}
+
+        if isinstance(transports, str):
+            # Single transport string: "stdio" or "http"
+            transport = transports.lower()
+            host = default_host or MCP_SERVER_HOST if transport in {"http", "sse"} else None
+            port = default_port or MCP_SERVER_PORT if transport in {"http", "sse"} else None
+            configs[transport] = TransportConfig(
+                transport=transport,
+                host=host,
+                port=port,
+            )
+
+        elif isinstance(transports, list):
+            # List of transport names: ["stdio", "http"]
+            for i, transport in enumerate(transports):
+                transport = transport.lower()
+                is_http_like = transport in {"http", "sse"}
+                port = ((default_port or MCP_SERVER_PORT) + i) if is_http_like else None
+                configs[transport] = TransportConfig(
+                    transport=transport,
+                    host=(default_host or MCP_SERVER_HOST) if is_http_like else None,
+                    port=port,
+                    name_suffix=f"{i}" if len(transports) > 1 else None,
+                )
+
+        elif isinstance(transports, dict):
+            # Full control: {"stdio": TransportConfig(...), "http": TransportConfig(...)}
+            configs = transports
+
+        return configs
+
+    def setup(self, app: web.Application) -> None:
+        """Register lifecycle hooks inside the aiohttp application."""
+        self.app = app
+        app["parrot_mcp_server"] = self
+        app.on_startup.append(self.on_startup)
+        app.on_shutdown.append(self.on_shutdown)
+        self.logger.notice(
+            ":: ParrotMCPServer registered for aiohttp app lifecycle management"
+        )
+
+    async def on_startup(self, app: web.Application) -> None:  # pylint: disable=unused-argument
+        """Start the MCP server once aiohttp finishes bootstrapping."""
+        tools = await self._load_configured_tools()
+        if not tools:
+            self.logger.info("No MCP tools configured to start")
+            return
+
+        # Start a server for each enabled transport
+        for transport_key, config in self.transport_configs.items():
+            if not config.enabled:
+                continue
+
+            server_name = self.name
+            if config.name_suffix:
+                server_name = f"{self.name}-{config.name_suffix}"
+
+            mcp_config = MCPServerConfig(
+                name=server_name,
+                description=self.description,
+                transport=config.transport,
+                host=config.host,
+                port=config.port,
+                log_level=self.log_level,
+            )
+
+            # Ensure MCP endpoints bypass the auth middleware (uses AuthHandler.exclude_list)
+            self._add_auth_exclusions(
+                [
+                    mcp_config.base_path,
+                    f"{mcp_config.base_path.rstrip('/')}/events",
+                    f"{mcp_config.base_path.rstrip('/')}/.well-known/oauth-authorization-server",
+                    f"{mcp_config.base_path.rstrip('/')}/oauth/register",
+                    f"{mcp_config.base_path.rstrip('/')}/oauth/authorize",
+                    f"{mcp_config.base_path.rstrip('/')}/oauth/token",
+                ]
+            )
+
+            if config.transport == "stdio":
+                server = MCPServer(mcp_config)
+                server.register_tools(tools)
+                self.servers[transport_key] = server
+
+                start_coro = server.start()
+                self._server_tasks[transport_key] = asyncio.create_task(start_coro)
+                self.logger.info(f"Spawned stdio MCP server task: {server_name}")
+
+            elif config.transport in {"http", "sse"}:
+                # Launch HTTP/SSE MCP server using existing aiohttp app
+                if config.transport == "sse":
+                    server = SseMCPServer(mcp_config, parent_app=app)
+                else:
+                    server = HttpMCPServer(mcp_config, parent_app=app)
+                server.register_tools(tools)
+                self.servers[transport_key] = server
+
+                # Solo registra rutas, no crea nueva app
+                await server.start()
+
+                self.logger.info(
+                    f"MCP server '{server_name}' routes registered on existing app"
+                )
+
+    async def on_shutdown(self, app: web.Application) -> None:  # pylint: disable=unused-argument
+        """Stop the MCP server when aiohttp starts shutting down."""
+        shutdown_errors = []
+
+        # Stop all servers
+        for transport_key, server in self.servers.items():
+            try:
+                await server.stop()
+                self.logger.info(f"Stopped MCP server: {transport_key}")
+            except Exception as exc:
+                shutdown_errors.append((transport_key, exc))
+                self.logger.error(f"Failed stopping MCP server {transport_key}: {exc}")
+
+        # Cancel stdio tasks
+        for transport_key, task in self._server_tasks.items():
+            if not task.done():
+                task.cancel()
+                with contextlib.suppress(asyncio.CancelledError):
+                    await task
+
+        self._server_tasks.clear()
+        self.servers.clear()
+
+        if shutdown_errors:
+            self.logger.warning(
+                f"Shutdown completed with {len(shutdown_errors)} errors"
+            )
+        else:
+            self.logger.info("All MCP servers shutdown complete")
+
+    def _add_auth_exclusions(self, paths: List[str]) -> None:
+        """Register paths that should bypass the Auth middleware (if present)."""
+        if not self.allow_anonymous:
+            return
+
+        if not self.app:
+            return
+
+        auth_handler = self.app.get("auth")
+        if not auth_handler:
+            self.logger.debug("Auth handler not found; skipping auth exclusions for MCP")
+            return
+
+        for path in paths:
+            auth_handler.add_exclude_list(path)
+            # Also add glob-style pattern to cover subpaths
+            if not path.endswith("*"):
+                auth_handler.add_exclude_list(f"{path}*")
+        self.logger.info("Registered MCP paths as auth exclusions: %s", paths)
+
+    async def _load_configured_tools(self) -> List[AbstractTool]:
+        """Instantiate every tool declared in configuration."""
+        loaded: List[AbstractTool] = []
+
+        if not self.tools_config:
+            return loaded
+
+        for class_name, module_path in self.tools_config.items():
+            if isinstance(module_path, (AbstractTool)):
+                loaded.append(module_path)
+                continue
+            elif isinstance(module_path, AbstractToolkit):
+                toolkit = module_path
+                await self._maybe_start_toolkit(toolkit, class_name)
+                loaded.extend(toolkit.get_tools())
+                continue
+            try:
+                module = import_module(module_path)
+                tool_cls = getattr(module, class_name)
+            except (ImportError, AttributeError) as exc:
+                self.logger.error(
+                    "Unable to import MCP tool %s from %s: %s",
+                    class_name,
+                    module_path,
+                    exc,
+                )
+                continue
+
+            instances = await self._initialize_tool(tool_cls, class_name)
+            if not instances:
+                continue
+
+            loaded.extend(instances)
+
+        self.logger.info("Loaded %s MCP tools", len(loaded))
+        return loaded
+
+    async def _initialize_tool(
+        self,
+        tool_cls,
+        class_name: str,
+    ) -> List[AbstractTool]:
+        """Instantiate either a toolkit or an individual AbstractTool."""
+        try:
+            instance = tool_cls()
+        except Exception as exc:
+            self.logger.error("Unable to instantiate %s: %s", class_name, exc)
+            return []
+
+        if isinstance(instance, AbstractToolkit):
+            await self._maybe_start_toolkit(instance, class_name)
+            return list(instance.get_tools())
+
+        if isinstance(instance, AbstractTool):
+            return [instance]
+
+        self.logger.warning(
+            "Configured MCP entry %s is neither an AbstractTool nor AbstractToolkit",
+            class_name,
+        )
+        return []
+
+    async def _maybe_start_toolkit(self, toolkit: AbstractToolkit, class_name: str) -> None:
+        """Call toolkit.start() when available."""
+        try:
+            result = toolkit.start()
+            if inspect.isawaitable(result):
+                await result
+            self.logger.debug("Toolkit %s started", class_name)
+        except Exception as exc:  # pragma: no cover - logging path
+            self.logger.error("Toolkit %s failed during startup: %s", class_name, exc)