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

mindroot/lib/plugins/installation.py

@@ -282,12 +282,12 @@ async def install_recommended_plugins(agent_name, context=None):
             for plugin_source in recommended_plugins:
                 for index in available_indices:
                     for plugin in index.get('plugins', []):
-                        remote_source = plugin.get('remote_source', plugin.get('github_url', plugin.get('source')))
-                        print(f"Checking plugin Index plugin {remote_source} against recommended {plugin_source}")
+                        remote_source = plugin.get('remote_source') or plugin.get('github_url') or plugin.get('source')
+                        print(f"Checking index plugin {remote_source} against recommended {plugin_source}")
                         if remote_source == plugin_source:
-                            if 'github.com/' in remote_source:
-                                github_path = github_url.split('github.com/')[1]
-                                print(f"Extracted GitHub path for {plugin_name}: {github_path}")
+                            if remote_source and 'github.com/' in remote_source:
+                                github_path = remote_source.split('github.com/')[1]
+                                print(f"Extracted GitHub path for {plugin_source}: {github_path}")
                                 plugin_sources[plugin_source] = github_path
                             elif remote_source:
                                 plugin_sources[plugin_source] = remote_source

mindroot/lib/plugins/l8n_static_handler.py

@@ -0,0 +1,225 @@
+import os
+import re
+from pathlib import Path
+from fastapi import Request, Response
+from fastapi.staticfiles import StaticFiles
+from starlette.responses import FileResponse
+from starlette.types import Scope, Receive, Send
+#from lib.utils.debug import debug_box
+import sys
+import traceback
+
+# Import l8n translation functions
+try:
+    from mindroot.coreplugins.l8n.utils import replace_placeholders, extract_plugin_root, get_localized_file_path, load_plugin_translations
+    from mindroot.coreplugins.l8n.middleware import get_request_language
+    from mindroot.coreplugins.l8n.language_detection import get_fallback_language
+    L8N_AVAILABLE = True
+except ImportError as e:
+    trace = traceback.format_exc()
+    print(f"L8n not available for static files: {e}\n{trace}")
+    L8N_AVAILABLE = False
+    sys.exit(1)
+
+class TranslatedStaticFiles(StaticFiles):
+    """Custom StaticFiles handler that applies l8n translations to JavaScript files."""
+    
+    def __init__(self, *, directory: str, plugin_name: str = None, **kwargs):
+        super().__init__(directory=directory, **kwargs)
+        self.plugin_name = plugin_name
+        self.directory_path = Path(directory)
+    
+    def get_current_language(self, request: Request) -> str:
+        """Get the current language for the request."""
+        print("Getting current language for static file request...")
+        if not L8N_AVAILABLE:
+            print("WARNING: L8n not available, defaulting to 'en'.")
+            return 'en'
+        
+        try:
+            # Try to get from request state first (set by middleware)
+            if hasattr(request.state, 'language'):
+                print(f"Using language from request state: {request.state.language}")
+                return request.state.language
+            
+            # Fallback to l8n middleware function
+            lang = get_request_language()
+            return get_fallback_language(lang) if lang else 'en'
+        except Exception as e:
+            print(f"Error getting language for static file: {e}")
+            return 'en'
+    
+    def should_translate_file(self, file_path: Path) -> bool:
+        """Check if a file should be translated."""
+        if not L8N_AVAILABLE:
+            print("L8n not available, skipping translation check.")
+            return False
+        
+        # show suffix
+        print(f"Checking if file should be translated: {file_path} suffix is {file_path.suffix}")
+        # Only translate JavaScript files for now
+        return file_path.suffix.lower() in ['.js', '.mjs']
+    
+    def apply_translations_to_js(self, content: str, language: str, file_path: str) -> str:
+        """Apply translations to JavaScript content.
+        
+        This looks for __TRANSLATE_key__ placeholders in JS files and replaces them
+        with translated strings. If translations are missing, returns None to
+        signal that the original file should be served instead.
+        """
+        if not L8N_AVAILABLE or not content:
+            return content
+        
+        try:
+            # Use the l8n replace_placeholders function
+            translated_content = replace_placeholders(content, language, file_path)
+            
+            # If None is returned, translations are incomplete
+            if translated_content is None:
+                print(f"L8n: Missing translations for JS file, will serve original: {file_path}")
+                return None
+            
+            return translated_content
+        except Exception as e:
+            print(f"Error applying translations to JS file {file_path}: {e}")
+            return None  # Fallback to original file on error
+    
+    async def get_response(self, path: str, scope: Scope) -> Response:
+        """Override to add translation support for JavaScript files."""
+        try:
+            # Get the full file path
+            full_path = self.directory_path / path
+            
+            # Check if file exists and should be translated
+            print(f"l8n Checking static file: {full_path}")
+            if full_path.exists() and self.should_translate_file(full_path):
+                print(f"l8n Translating static file: {full_path}")
+                # Create a request object to get language
+                request = Request(scope)
+                current_language = self.get_current_language(request)
+                print(f"[UPDATE] l8n Current language for static file: {current_language}")
+
+                localized_path = get_localized_file_path(str(full_path))
+
+                # Check if localized file exists
+                if localized_path.exists():
+                    # Read the localized file content
+                    with open(localized_path, "r", encoding="utf-8") as f:
+                        content = f.read()
+                    
+                    # Apply translations
+                    translated_content = self.apply_translations_to_js(
+                        content, current_language, str(localized_path)
+                    )
+                    
+                    # If translations are complete, serve translated content
+                    if translated_content is not None:
+                        print(f"l8n: Serving translated JS file: {full_path}")
+                        return Response(
+                            content=translated_content,
+                            media_type="application/javascript",
+                            headers={
+                                "Cache-Control": "no-cache, no-store, must-revalidate",
+                                "Pragma": "no-cache",
+                                "Expires": "0"
+                            }
+                        )
+                    else:
+                        print(f"l8n: Translations incomplete, serving original JS file: {full_path}")
+                else:
+                    print(f"l8n: No localized version found, serving original JS file: {full_path}")
+            # For non-JS files or when translation is not available, use default behavior
+            print(f"l8n Serving static file without translation: {full_path}")
+            return await super().get_response(path, scope)
+            
+        except Exception as e:
+            trace = traceback.format_exc()
+            print(f"Error in translated static file handler: {e}\n{trace}")
+            # Fallback to default behavior on error
+            return await super().get_response(path, scope)
+
+def mount_translated_static_files(app, plugin_name: str, category: str):
+    """Mount plugin static files with translation support.
+    
+    Args:
+        app (FastAPI): The FastAPI application instance
+        plugin_name (str): Name of the plugin
+        category (str): Plugin category ('core' or 'installed')
+    """
+    from .paths import get_plugin_path
+    
+    # debug_box(f"Mounting translated static files for plugin: {plugin_name} in category: {category}")
+
+    plugin_dir = get_plugin_path(plugin_name)
+    if not plugin_dir:
+        return
+        
+    dir_name = os.path.basename(plugin_dir)
+    
+    if category != 'core': 
+        static_path = os.path.join(plugin_dir, 'src', dir_name, 'static')
+        if not os.path.exists(static_path):
+            static_path = os.path.join(plugin_dir, 'static')
+    else:
+        static_path = os.path.join(plugin_dir, 'static')
+
+    if os.path.exists(static_path):
+        # Use our custom TranslatedStaticFiles instead of regular StaticFiles
+        app.mount(
+            f"/{dir_name}/static", 
+            TranslatedStaticFiles(directory=static_path, plugin_name=plugin_name), 
+            name=f"/{dir_name}/static"
+        )
+        print(f"Mounted translated static files for plugin: {plugin_name} at {static_path}")
+        #debug_box(f"Mounted translated static files for plugin: {plugin_name} at {static_path}")
+    else:
+        print(f"No static files found for plugin: {plugin_name}. Searched in {static_path}")
+        #debug_box(f"No static files found for plugin: {plugin_name}. Searched in {static_path}")
+
+# JavaScript-specific translation helpers
+def create_js_translation_object(translations: dict) -> str:
+    """Create a JavaScript object containing translations.
+    
+    This can be injected into JS files to provide client-side translation support.
+    
+    Args:
+        translations: Dictionary of translation key-value pairs
+        
+    Returns:
+        JavaScript code defining a translation object
+    """
+    import json
+    
+    # Safely serialize translations to JavaScript
+    js_translations = json.dumps(translations, ensure_ascii=False)
+    
+    return f"""
+// Auto-generated translation object
+window.MINDROOT_TRANSLATIONS = {js_translations};
+
+// Helper function to get translations
+window.translate = function(key, fallback) {{
+    return window.MINDROOT_TRANSLATIONS[key] || fallback || key;
+}};
+
+// Alias for shorter usage
+window.t = window.translate;
+"""
+
+def inject_translations_into_js(content: str, translations: dict) -> str:
+    """Inject translation object into JavaScript content.
+    
+    This prepends translation definitions to JS files.
+    
+    Args:
+        content: Original JavaScript content
+        translations: Translation dictionary
+        
+    Returns:
+        JavaScript content with translations injected
+    """
+    if not translations:
+        return content
+    
+    translation_js = create_js_translation_object(translations)
+    return translation_js + "\n\n" + content

mindroot/lib/plugins/loader.py

@@ -11,6 +11,15 @@ from .manifest import list_enabled, load_plugin_manifest
 from .installation import check_plugin_dependencies
 from mindroot.lib.utils.debug import debug_box
 
+# Try to import l8n static handler
+try:
+    from .l8n_static_handler import mount_translated_static_files
+    L8N_STATIC_AVAILABLE = True
+except ImportError as e:
+    print(f"L8n static handler not available: {e}")
+    debug_box("L8n static handler not available, falling back to regular static files")
+    L8N_STATIC_AVAILABLE = False
+
 app_instance = None
 
 def load_middleware(app, plugin_name, plugin_path, category):
@@ -67,13 +76,23 @@ def load_middleware(app, plugin_name, plugin_path, category):
         print(f"No middleware loaded for plugin: {plugin_name}")
 
 def mount_static_files(app, plugin_name, category):
-    """Mount plugin static files if they exist.
+    """Mount plugin static files with translation support if available.
     
     Args:
         app (FastAPI): The FastAPI application instance
         plugin_name (str): Name of the plugin
         category (str): Plugin category ('core' or 'installed')
     """
+    # Try to use translated static files first if l8n is available
+    if L8N_STATIC_AVAILABLE:
+        try:
+            mount_translated_static_files(app, plugin_name, category)
+            return
+        except Exception as e:
+            print(f"Could not mount translated static files for {plugin_name}: {e}")
+            print("Falling back to regular static file mounting")
+    
+    # Fallback to regular static file mounting
     plugin_dir = get_plugin_path(plugin_name)
     if not plugin_dir:
         return
@@ -145,7 +164,7 @@ async def pre_load(app=None):
             print("Error in pre_load: " + str(e))
  
 async def load(app=None):
-    """Load all enabled plugins.
+    """Load all enabled plugins with l8n translation support.
     
     Args:
         app (FastAPI, optional): The FastAPI application instance
@@ -197,6 +216,11 @@ async def load(app=None):
                 continue
 
             # Import plugin module
+            print(termcolor.colored(
+                f"Tryin to import plugin: {plugin_name} ({category})", 
+                'green'
+            ))
+#
             try:
                 module = importlib.import_module(plugin_path)
             except ImportError:
@@ -234,6 +258,11 @@ async def load(app=None):
                     router_path = os.path.join(plugin_dir, 'router.py')
 
                 if os.path.exists(router_path):
+                    print(termcolor.colored(
+                        f"Trying to include router for plugin: {plugin_name} path {plugin_path}",
+                        'yellow'
+                    ))
+ 
                     router_module = importlib.import_module(f"{plugin_path}.router")
                     app.include_router(router_module.router)
                     print(termcolor.colored(
@@ -247,7 +276,8 @@ async def load(app=None):
                 trace = traceback.format_exc()
                 print(termcolor.colored(
                     f"Failed to load router for plugin: {plugin_name}\n{str(e)}\n{trace}",'red'))
-            # Mount static files
+            
+            # Mount static files with translation support
             mount_static_files(app, plugin_name, category)
 
         except Exception as e:

mindroot/lib/plugins/loader_with_l8n.py

@@ -0,0 +1,281 @@
+import os
+import sys
+import importlib
+import termcolor
+import traceback
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+from starlette.middleware.base import BaseHTTPMiddleware
+from .paths import get_plugin_path, get_plugin_import_path
+from .manifest import list_enabled, load_plugin_manifest
+from .installation import check_plugin_dependencies
+from .l8n_static_handler import mount_translated_static_files
+from mindroot.lib.utils.debug import debug_box
+
+app_instance = None
+
+def load_middleware(app, plugin_name, plugin_path, category):
+    """Load plugin middleware if it exists.
+    
+    Args:
+        app (FastAPI): The FastAPI application instance
+        plugin_name (str): Name of the plugin
+        plugin_path (str): Import path of the plugin
+    """
+    try:
+        plugin_dir = plugin_path # get_plugin_path(plugin_name)
+        if not plugin_dir:
+            print("No plugin_dir")
+            return
+            
+        dir_name = os.path.basename(plugin_dir)
+        
+        if category != 'core': 
+            middleware_path = os.path.join(plugin_dir, 'src', dir_name, 'middleware.py')
+        else:
+            middleware_path = os.path.join(plugin_dir, 'middleware.py')
+
+        if os.path.exists(middleware_path):
+
+            plugin_import_path = get_plugin_import_path(plugin_name)
+            if not plugin_import_path:
+                failed_plugins.append(
+                    (plugin_name, f"Failed to locate plugin: {plugin_name}")
+                )
+                print(f"Could not load middleware for plugin, failed to locate import path {plugin_name}")
+                return
+
+            module = None
+            # Import plugin module
+            try:
+                module = importlib.import_module(plugin_import_path)
+            except ImportError:
+                module = importlib.import_module(f"{plugin_import_path}.mod")
+
+            print(termcolor.colored(
+                f"Loaded plugin: {plugin_name} ({category})", 
+                'green'
+            ))
+            if hasattr(module, 'middleware'):
+                app.add_middleware(BaseHTTPMiddleware, dispatch=module.middleware)
+                print(f"Added middleware for plugin: {plugin_name}")
+        else:
+            print(f"Did not find middleware for {plugin_name} in {middleware_path}")
+    except ImportError as e:
+        trace = traceback.format_exc()
+ 
+        print(f"Could not import middleware for plugin {plugin_name} error was {e}\n\n{trace}")
+        print(f"No middleware loaded for plugin: {plugin_name}")
+
+def mount_static_files(app, plugin_name, category):
+    """Mount plugin static files with translation support if available.
+    
+    Args:
+        app (FastAPI): The FastAPI application instance
+        plugin_name (str): Name of the plugin
+        category (str): Plugin category ('core' or 'installed')
+    """
+    try:
+        # Try to use translated static files first
+        mount_translated_static_files(app, plugin_name, category)
+        return
+    except Exception as e:
+        print(f"Could not mount translated static files for {plugin_name}: {e}")
+        print("Falling back to regular static file mounting")
+    
+    # Fallback to regular static file mounting
+    plugin_dir = get_plugin_path(plugin_name)
+    if not plugin_dir:
+        return
+        
+    dir_name = os.path.basename(plugin_dir)
+    
+    if category != 'core': 
+        static_path = os.path.join(plugin_dir, 'src', dir_name, 'static')
+        if not os.path.exists(static_path):
+            static_path = os.path.join(plugin_dir, 'static')
+    else:
+        static_path = os.path.join(plugin_dir, 'static')
+
+    if os.path.exists(static_path):
+        app.mount(
+            f"/{dir_name}/static", 
+            StaticFiles(directory=static_path), 
+            name=f"/{dir_name}/static"
+        )
+        print(termcolor.colored(
+            f"Mounted static files for plugin: {plugin_name} at {static_path}", 
+            'green'
+        ))
+    else:
+        print(termcolor.colored(
+            f"No static files found for plugin: {plugin_name}. Searched in {static_path}",
+            'yellow'
+        ))
+
+# pre_startup (e.g. middleware)
+async def pre_load(app=None):
+    debug_box("Top of pre_load")
+    enabled_plugins = list_enabled()
+    global app_instance
+
+    # Setup app instance
+    if app is not None:
+        app_instance = app
+    elif app_instance is not None:
+        app = app_instance
+    else:
+        raise Exception("No FastAPI app instance provided or found")
+
+    # Add project root to Python path
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    project_root = os.path.dirname(os.path.dirname(current_dir))
+    if project_root not in sys.path:
+        sys.path.insert(0, project_root)
+
+    failed_plugins = []
+
+    enabled_plugins = [plugin for plugin in enabled_plugins if plugin[0] != 'startup']
+    print("inside of pre_load")
+    for plugin_name, category in enabled_plugins:
+        try:
+            print(f"Trying to get import path for {plugin_name}")
+            # Get plugin import path
+            plugin_path = get_plugin_path(plugin_name)
+            if not plugin_path:
+                failed_plugins.append(
+                    (plugin_name, f"Failed to locate plugin: {plugin_name}")
+                )
+                print("Could not get import path")
+                continue
+
+            print(f"Trying to load middleware (if any) for {plugin_name}")
+            load_middleware(app, plugin_name, plugin_path, category)
+        except Exception as e: 
+            print("Error in pre_load: " + str(e))
+ 
+async def load(app=None):
+    """Load all enabled plugins with l8n translation support.
+    
+    Args:
+        app (FastAPI, optional): The FastAPI application instance
+        
+    Raises:
+        Exception: If no FastAPI instance is provided or found
+    """
+    global app_instance
+
+    # Setup app instance
+    if app is not None:
+        app_instance = app
+    elif app_instance is not None:
+        app = app_instance
+    else:
+        raise Exception("No FastAPI app instance provided or found")
+
+    # Add project root to Python path
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    project_root = os.path.dirname(os.path.dirname(current_dir))
+    if project_root not in sys.path:
+        sys.path.insert(0, project_root)
+
+    # Load enabled plugins
+    enabled_plugins = list_enabled()
+    failed_plugins = []
+
+    enabled_plugins = [plugin for plugin in enabled_plugins if plugin[0] != 'startup']
+    enabled_plugins.append(('startup', 'core'))
+
+    print("Enabled plugins:")
+    print(enabled_plugins)
+
+    for plugin_name, category in enabled_plugins:
+        try:
+            # Get plugin import path
+            plugin_path = get_plugin_import_path(plugin_name)
+            if not plugin_path:
+                failed_plugins.append(
+                    (plugin_name, f"Failed to locate plugin: {plugin_name}")
+                )
+                continue
+
+            # Check dependencies for non-core plugins
+            if category != 'core' and not check_plugin_dependencies(plugin_path):
+                failed_plugins.append(
+                    (plugin_name, f"Dependencies not met for plugin {plugin_name}")
+                )
+                continue
+
+            # Import plugin module
+            try:
+                print(plugin_name, "Trying to import plugin module: " + plugin_path)
+                module = importlib.import_module(plugin_path)
+            except ImportError:
+                module = importlib.import_module(f"{plugin_path}.mod")
+
+            print(termcolor.colored(
+                f"Loaded plugin: {plugin_name} ({category})", 
+                'green'
+            ))
+
+            # Call plugin initialization
+            if hasattr(module, 'on_load'):
+                print(termcolor.colored(
+                    f"Calling on_load() for plugin: {plugin_name}",
+                    'yellow', 'on_green'
+                ))
+                await module.on_load(app)
+
+            # Load router if exists
+            try:
+                # we need to see if the router.py actually exists
+                # because if not this isn't an error, it just means there is no router
+                # but if there is and we get an importerror, then we need to report that
+                # as an error
+                # so to detect if the file exists we need to import os
+                plugin_dir = get_plugin_path(plugin_name)
+                if not plugin_dir:
+                    return
+                    
+                dir_name = os.path.basename(plugin_dir)
+                
+                if category != 'core': 
+                    router_path = os.path.join(plugin_dir, 'src', dir_name, 'router.py')
+                else:
+                    router_path = os.path.join(plugin_dir, 'router.py')
+
+                if os.path.exists(router_path):
+                    print(termcolor.colored(
+                        f">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Trying to load router for plugin: {plugin_name}",
+                        'green'
+                    ))
+ 
+                    print("Trying to load router for plugin: " + plugin_name)
+                    router_module = importlib.import_module(f"{plugin_path}.router")
+                    app.include_router(router_module.router)
+                    print(termcolor.colored(
+                        f"Included router for plugin: {plugin_name}",
+                        'yellow'
+                    ))
+                else:
+                    print(f"No router found for plugin: {plugin_name} at path {plugin_path}/router.py")
+
+            except ImportError as e:
+                trace = traceback.format_exc()
+                print(termcolor.colored(
+                    f"Failed to load router for plugin: {plugin_name}\n{str(e)}\n{trace}",'red'))
+            
+            # Mount static files with translation support
+            mount_static_files(app, plugin_name, category)
+
+        except Exception as e:
+            trace = traceback.format_exc()
+            failed_plugins.append(
+                (plugin_name, f"Failed to load plugin: {str(e)}\n{trace}")
+            )
+
+    # Report failed plugins
+    if failed_plugins:
+        print(termcolor.colored("Failed to load the following plugins:", 'red'))
+        for plugin_name, reason in failed_plugins:
+            print(f"{plugin_name}: {reason}")