mindroot 9.3.0__py3-none-any.whl → 9.6.0__py3-none-any.whl

mindroot/coreplugins/chat/static/site.webmanifest

@@ -1 +1 @@
-{"name":"","short_name":"","icons":[{"src":"/static/favicon/android-chrome-192x192.png","sizes":"192x192","type":"image/png"},{"src":"/static/favicon/android-chrome-512x512.png","sizes":"512x512","type":"image/png"}],"theme_color":"#ffffff","background_color":"#ffffff","display":"standalone"}
+{"name":"","short_name":"","icons":[{"src":"/imgs/logo.png","sizes":"192x192","type":"image/png"},{"src":"/imgs/logo.png","sizes":"512x512","type":"image/png"}],"theme_color":"#ffffff","background_color":"#ffffff","display":"standalone"}

mindroot/coreplugins/chat/templates/chat.jinja2

@@ -29,9 +29,9 @@
   {% endblock %}
 
   {% block head_favicon %}
-  <link rel="apple-touch-icon" sizes="180x180" href="/chat/static/favicon/apple-touch-icon.png">
-  <link rel="icon" type="image/png" sizes="32x32" href="/chat/static/favicon/favicon-32x32.png">
-  <link rel="icon" type="image/png" sizes="16x16" href="/chat/static/favicon/favicon-16x16.png">
+  <link rel="apple-touch-icon" sizes="180x180" href="/imgs/logo.png">
+  <link rel="icon" type="image/png" sizes="32x32" href="/imgs/logo.png">
+  <link rel="icon" type="image/png" sizes="16x16" href="/imgs/logo.png">
   {% endblock %}
 
   {% block head_extra %}{% endblock %}

mindroot/coreplugins/chat/widget_manager.py

@@ -0,0 +1,139 @@
+import json
+import nanoid
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, Optional, List
+
+class WidgetManager:
+    """Manages secure widget tokens for chat embedding."""
+    
+    def __init__(self, widgets_dir: str = "data/widgets"):
+        self.widgets_dir = Path(widgets_dir)
+        self.widgets_dir.mkdir(parents=True, exist_ok=True)
+        self._load_widgets()
+    
+    def _load_widgets(self) -> None:
+        """Load all widget tokens from storage."""
+        self.widgets = {}
+        for widget_file in self.widgets_dir.glob("*.json"):
+            try:
+                with open(widget_file, 'r') as f:
+                    widget_data = json.load(f)
+                    self.widgets[widget_data['token']] = widget_data
+            except json.JSONDecodeError:
+                print(f"Warning: Invalid JSON in widget file: {widget_file}")
+            except Exception as e:
+                print(f"Error loading widget file {widget_file}: {e}")
+    
+    def create_widget_token(self, api_key: str, agent_name: str, base_url: str, 
+                           created_by: str, description: str = "", 
+                           styling: Optional[Dict] = None) -> str:
+        """Create a new widget token and store its configuration.
+        
+        Args:
+            api_key: The API key to use for authentication
+            agent_name: The agent to use for chat sessions
+            base_url: The base URL for the MindRoot instance
+            created_by: Username of the creator
+            description: Optional description for the widget
+            styling: Optional styling configuration
+            
+        Returns:
+            The generated widget token
+        """
+        token = nanoid.generate()
+        
+        if styling is None:
+            styling = {
+                "position": "bottom-right",
+                "theme": "dark",
+                "width": "400px",
+                "height": "600px"
+            }
+        
+        widget_data = {
+            "token": token,
+            "api_key": api_key,
+            "agent_name": agent_name,
+            "base_url": base_url,
+            "created_at": datetime.utcnow().isoformat(),
+            "created_by": created_by,
+            "description": description,
+            "styling": styling
+        }
+        
+        # Save to file
+        widget_file = self.widgets_dir / f"{token}.json"
+        with open(widget_file, 'w') as f:
+            json.dump(widget_data, f, indent=2)
+        
+        self.widgets[token] = widget_data
+        return token
+    
+    def get_widget_config(self, token: str) -> Optional[Dict]:
+        """Retrieve widget configuration by token.
+        
+        Args:
+            token: The widget token
+            
+        Returns:
+            Widget configuration dict if found, None otherwise
+        """
+        return self.widgets.get(token)
+    
+    def delete_widget_token(self, token: str) -> bool:
+        """Delete a widget token and its configuration.
+        
+        Args:
+            token: The widget token to delete
+            
+        Returns:
+            True if deleted successfully, False if not found
+        """
+        if token in self.widgets:
+            widget_file = self.widgets_dir / f"{token}.json"
+            try:
+                widget_file.unlink(missing_ok=True)
+                del self.widgets[token]
+                return True
+            except Exception as e:
+                print(f"Error deleting widget file {widget_file}: {e}")
+                return False
+        return False
+    
+    def list_widget_tokens(self, created_by: Optional[str] = None) -> List[Dict]:
+        """List all widget tokens, optionally filtered by creator.
+        
+        Args:
+            created_by: Optional username to filter by
+            
+        Returns:
+            List of widget configurations (with API keys hidden)
+        """
+        widgets = []
+        
+        for widget_data in self.widgets.values():
+            # Filter by creator if specified
+            if created_by and widget_data.get("created_by") != created_by:
+                continue
+            
+            # Create safe copy without exposing API key
+            safe_widget = widget_data.copy()
+            safe_widget["api_key"] = "***hidden***"
+            widgets.append(safe_widget)
+        
+        return sorted(widgets, key=lambda x: x.get("created_at", ""), reverse=True)
+    
+    def validate_token(self, token: str) -> bool:
+        """Check if a widget token is valid.
+        
+        Args:
+            token: The widget token to validate
+            
+        Returns:
+            True if valid, False otherwise
+        """
+        return token in self.widgets
+
+# Global widget manager instance
+widget_manager = WidgetManager()

mindroot/coreplugins/chat/widget_routes.py

@@ -0,0 +1,287 @@
+from fastapi import APIRouter, HTTPException, Request, Response
+from fastapi.responses import HTMLResponse
+from pydantic import BaseModel
+from typing import Optional, List
+from .widget_manager import widget_manager
+from lib.auth.api_key import verify_api_key
+from lib.providers.services import service_manager
+from lib.route_decorators import public_route
+import nanoid
+from .services import init_chat_session
+from lib.session_files import save_session_data
+import traceback
+
+router = APIRouter()
+
+class WidgetTokenCreate(BaseModel):
+    api_key: str
+    agent_name: str
+    base_url: str
+    description: Optional[str] = ""
+    styling: Optional[dict] = None
+
+class WidgetTokenResponse(BaseModel):
+    token: str
+    agent_name: str
+    base_url: str
+    description: str
+    created_at: str
+    created_by: str
+    styling: dict
+
+@router.post("/widgets/create")
+async def create_widget_token(request: Request, widget_request: WidgetTokenCreate):
+    """Create a new widget token."""
+    try:
+        # Verify the API key is valid
+        api_key_data = await verify_api_key(widget_request.api_key)
+        if not api_key_data:
+            raise HTTPException(status_code=400, detail="Invalid API key")
+        
+        # Verify the agent exists
+        try:
+            agent_data = await service_manager.get_agent_data(widget_request.agent_name)
+            if not agent_data:
+                raise HTTPException(status_code=400, detail="Agent not found")
+        except Exception:
+            raise HTTPException(status_code=400, detail="Agent not found")
+        
+        # Get the current user
+        user = request.state.user
+        
+        # Create the widget token
+        token = widget_manager.create_widget_token(
+            api_key=widget_request.api_key,
+            agent_name=widget_request.agent_name,
+            base_url=widget_request.base_url,
+            created_by=user.username,
+            description=widget_request.description,
+            styling=widget_request.styling
+        )
+        
+        return {
+            "success": True,
+            "token": token,
+            "embed_url": f"{widget_request.base_url}/chat/embed/{token}"
+        }
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/widgets/list")
+async def list_widget_tokens(request: Request):
+    """List widget tokens for the current user."""
+    try:
+        user = request.state.user
+        widgets = widget_manager.list_widget_tokens(created_by=user.username)
+        return {"success": True, "data": widgets}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.delete("/widgets/delete/{token}")
+async def delete_widget_token(request: Request, token: str):
+    """Delete a widget token."""
+    try:
+        # Verify the widget exists and belongs to the user
+        widget_config = widget_manager.get_widget_config(token)
+        if not widget_config:
+            raise HTTPException(status_code=404, detail="Widget token not found")
+        
+        user = request.state.user
+        if widget_config.get("created_by") != user.username:
+            raise HTTPException(status_code=403, detail="Not authorized to delete this widget")
+        
+        success = widget_manager.delete_widget_token(token)
+        if success:
+            return {"success": True, "message": "Widget token deleted successfully"}
+        else:
+            raise HTTPException(status_code=500, detail="Failed to delete widget token")
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/chat/embed/{token}")
+@public_route()
+async def get_embed_script(token: str):
+    """Generate the secure embed script for a widget token."""
+    try:
+        # Validate the widget token
+        widget_config = widget_manager.get_widget_config(token)
+        if not widget_config:
+            raise HTTPException(status_code=404, detail="Widget token not found")
+        
+        # Generate the embed JavaScript
+        base_url = widget_config["base_url"]
+        styling = widget_config.get("styling", {})
+        
+        # Create the embed script that doesn't expose the API key
+        embed_script = f'''
+(function() {{
+    const config = {{
+        baseUrl: "{base_url}",
+        token: "{token}",
+        position: "{styling.get('position', 'bottom-right')}",
+        width: "{styling.get('width', '400px')}",
+        height: "{styling.get('height', '600px')}",
+        theme: "{styling.get('theme', 'dark')}"
+    }};
+    
+    let chatContainer = null;
+    let chatIcon = null;
+    let isLoaded = false;
+    
+    function createChatIcon() {{
+        if (chatIcon) return;
+        
+        chatIcon = document.createElement("div");
+        chatIcon.id = "mindroot-chat-icon-" + config.token;
+        chatIcon.innerHTML = "💬";
+        
+        const iconStyles = {{
+            position: "fixed",
+            bottom: "20px",
+            right: config.position.includes("left") ? "auto" : "20px",
+            left: config.position.includes("left") ? "20px" : "auto",
+            width: "60px",
+            height: "60px",
+            background: "#2196F3",
+            borderRadius: "50%",
+            display: "flex",
+            alignItems: "center",
+            justifyContent: "center",
+            cursor: "pointer",
+            boxShadow: "0 4px 12px rgba(0, 0, 0, 0.3)",
+            zIndex: "10000",
+            fontSize: "24px",
+            color: "white",
+            transition: "all 0.3s ease"
+        }};
+        
+        Object.assign(chatIcon.style, iconStyles);
+        chatIcon.addEventListener("click", toggleChat);
+        document.body.appendChild(chatIcon);
+    }}
+    
+    function createChatContainer() {{
+        if (chatContainer) return;
+        
+        chatContainer = document.createElement("div");
+        chatContainer.id = "mindroot-chat-container-" + config.token;
+        
+        const containerStyles = {{
+            position: "fixed",
+            bottom: "90px",
+            right: config.position.includes("left") ? "auto" : "20px",
+            left: config.position.includes("left") ? "20px" : "auto",
+            width: config.width,
+            height: config.height,
+            background: "white",
+            borderRadius: "12px",
+            boxShadow: "0 8px 32px rgba(0, 0, 0, 0.3)",
+            zIndex: "10001",
+            display: "none",
+            overflow: "hidden"
+        }};
+        
+        Object.assign(chatContainer.style, containerStyles);
+        document.body.appendChild(chatContainer);
+    }}
+    
+    function toggleChat() {{
+        if (!chatContainer) createChatContainer();
+        
+        const isVisible = chatContainer.style.display !== "none";
+        
+        if (isVisible) {{
+            chatContainer.style.display = "none";
+        }} else {{
+            if (!isLoaded) {{
+                // Create iframe and load the secure session
+                const iframe = document.createElement("iframe");
+                iframe.style.cssText = "width: 100%; height: 100%; border: none; border-radius: 12px;";
+                iframe.src = config.baseUrl + "/chat/widget/" + config.token + "/session";
+                chatContainer.appendChild(iframe);
+                isLoaded = true;
+            }}
+            chatContainer.style.display = "block";
+        }}
+    }}
+    
+    function init() {{
+        if (document.readyState === "loading") {{
+            document.addEventListener("DOMContentLoaded", function() {{
+                createChatIcon();
+            }});
+        }} else {{
+            createChatIcon();
+        }}
+    }}
+    
+    init();
+}})();
+'''
+        
+        return Response(
+            content=embed_script,
+            media_type="application/javascript",
+            headers={
+                "Cache-Control": "no-cache, no-store, must-revalidate",
+                "Pragma": "no-cache",
+                "Expires": "0"
+            }
+        )
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/chat/widget/{token}/session")
+@public_route()
+async def create_widget_session(token: str):
+    """Create a secure chat session for a widget token."""
+    try:
+        # Validate the widget token
+        widget_config = widget_manager.get_widget_config(token)
+        if not widget_config:
+            raise HTTPException(status_code=404, detail="Widget token not found")
+        
+        # Verify the API key from the widget config
+        api_key_data = await verify_api_key(widget_config["api_key"])
+        if not api_key_data:
+            raise HTTPException(status_code=401, detail="Invalid API key in widget configuration")
+        
+        # Create mock user and generate session ID
+        class MockUser:
+            def __init__(self, username):
+                self.username = username
+        user = MockUser(api_key_data['username'])
+        session_id = nanoid.generate()
+        agent_name = widget_config["agent_name"]
+        
+        # Initialize the chat session (this was missing!)
+        await init_chat_session(user, agent_name, session_id)
+        
+        # Create and save access token for authentication
+        from coreplugins.jwt_auth.middleware import create_access_token
+        token_data = create_access_token({"sub": api_key_data['username']})
+        await save_session_data(session_id, "access_token", token_data)
+        
+        # Now redirect to the session WITHOUT exposing the API key
+        redirect_url = f"/session/{agent_name}/{session_id}?embed=true"
+        
+        return Response(
+            status_code=302,
+            headers={"Location": redirect_url}
+        )
+    
+    except Exception as e:
+        trace = traceback.format_exc()
+        print(e, trace)
+        raise HTTPException(status_code=500, detail=str(e))
+        

mindroot/coreplugins/check_list/inject/admin.jinja2

@@ -3,7 +3,7 @@
 {% endblock %}
 
 {% block content %}
-<details>
+<details data-inject-category="advanced">
   <summary><span class="material-icons">checklist</span>
   <span>Checklist Helper</span>
   </summary>

mindroot/coreplugins/email/__init__.py

@@ -0,0 +1,2 @@
+from .mod import *
+from .services import *

mindroot/coreplugins/email/email_provider.py

@@ -1,6 +1,6 @@
 from typing import Dict, List
-from smtp_handler import SMTPHandler
-from imap_handler import IMAPHandler
+from .smtp_handler import SMTPHandler
+from .imap_handler import IMAPHandler
 import logging
 
 logger = logging.getLogger(__name__)

mindroot/coreplugins/email/mod.py

@@ -0,0 +1,100 @@
+from lib.providers.services import service
+from .email_provider import EmailProvider
+from .services import init_provider as _init_provider, get_provider as _get_provider
+from typing import Dict
+import os
+import logging
+
+logger = logging.getLogger(__name__)
+
+# Global provider instance
+_provider = None
+
+@service()
+async def init_email_provider(config: Dict = None, context=None) -> bool:
+    """Initialize the email provider with config"""
+    global _provider
+    
+    if config is None:
+        # Use environment variables for default config
+        config = {
+            'smtp_server': os.getenv('SMTP_SERVER', 'smtp.gmail.com'),
+            'smtp_port': int(os.getenv('SMTP_PORT', '587')),
+            'use_tls': os.getenv('SMTP_USE_TLS', 'true').lower() == 'true',
+            'email': os.getenv('SMTP_EMAIL', ''),
+            'password': os.getenv('SMTP_PASSWORD', ''),
+            'imap_server': os.getenv('IMAP_SERVER', 'imap.gmail.com'),
+            'imap_port': int(os.getenv('IMAP_PORT', '993'))
+        }
+    
+    if not config['email'] or not config['password']:
+        logger.warning("Email provider not initialized: missing SMTP_EMAIL or SMTP_PASSWORD")
+        return False
+    
+    try:
+        _provider = EmailProvider(config)
+        logger.info("Email provider initialized successfully")
+        return True
+    except Exception as e:
+        logger.error(f"Failed to initialize email provider: {e}")
+        return False
+
+@service()
+async def send_email(to: str, subject: str, body: str, context=None) -> Dict:
+    """Service to send an email
+    
+    Args:
+        to: Recipient email address
+        subject: Email subject
+        body: Email body (can be plain text or HTML - auto-detected)
+        context: Optional context
+    
+    Returns:
+        Dict with success status and error info
+    """
+    global _provider
+    
+    if _provider is None:
+        # Try to initialize with default config
+        success = await init_email_provider(context=context)
+        if not success:
+            return {
+                "success": False,
+                "error": "Email provider not initialized"
+            }
+    
+    try:
+        result = await _provider.send_email(
+            to=to,
+            subject=subject,
+            body=body
+        )
+        return result
+    except Exception as e:
+        logger.error(f"Error sending email: {e}")
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
+@service()
+async def check_emails(folder: str = "INBOX", criteria: Dict = None, context=None) -> Dict:
+    """Service to check for new emails"""
+    global _provider
+    
+    if _provider is None:
+        success = await init_email_provider(context=context)
+        if not success:
+            return {
+                "success": False,
+                "error": "Email provider not initialized"
+            }
+    
+    try:
+        return await _provider.check_emails(folder=folder, criteria=criteria)
+    except Exception as e:
+        logger.error(f"Error checking emails: {e}")
+        return {
+            "success": False,
+            "error": str(e)
+        }

mindroot/coreplugins/email/services.py

@@ -1,5 +1,5 @@
 from typing import Dict, List, Optional
-from email_provider import EmailProvider
+from .email_provider import EmailProvider
 
 # Global provider instance
 _provider = None
@@ -16,10 +16,12 @@ async def get_provider() -> EmailProvider:
         raise RuntimeError("Email provider not initialized. Call init_provider first.")
     return _provider
 
-async def send_email(config: Dict, to: str, subject: str, body: str,
+# Removed @service() decorator - this is now just a helper function
+# The actual service is in mod.py
+async def send_email_helper(config: Dict, to: str, subject: str, body: str,
                reply_to_message: Dict = None,
                headers: Dict = None) -> Dict:
-    """Service to send an email"""
+    """Helper function to send an email (not a service)"""
     provider = await get_provider()
     return await provider.send_email(
         to=to,

mindroot/coreplugins/email/smtp_handler.py

@@ -36,7 +36,7 @@ class SMTPHandler:
         try:
             server = await self.connect()
             
-            msg = MIMEMultipart()
+            msg = MIMEMultipart('alternative')
             msg['From'] = self.email
             msg['To'] = to
             msg['Subject'] = subject
@@ -52,14 +52,20 @@ class SMTPHandler:
                 if not subject.lower().startswith('re:'):
                     msg['Subject'] = f"Re: {subject}"
 
-            msg.attach(MIMEText(body, 'plain'))
+            # Detect if body contains HTML
+            if '<html>' in body.lower() or '<p>' in body.lower() or '<br>' in body.lower():
+                # HTML email
+                msg.attach(MIMEText(body, 'html'))
+            else:
+                # Plain text email
+                msg.attach(MIMEText(body, 'plain'))
             
             server.send_message(msg)
             server.quit()
 
             return {
                 "success": True,
-                "message_id": msg['Message-ID'],
+                "message_id": msg.get('Message-ID'),
                 "error": None
             }