mindroot 9.2.0__py3-none-any.whl → 9.5.0__py3-none-any.whl

mindroot/coreplugins/user_service/password_reset_service.py

@@ -1,3 +1,4 @@
+from typing import Optional
 from lib.providers.services import service
 from .models import UserAuth, PasswordResetToken
 import bcrypt
@@ -5,19 +6,47 @@ import json
 import os
 import secrets
 from datetime import datetime, timedelta
+import logging
+
+logger = logging.getLogger(__name__)
 
 USER_DATA_ROOT = "data/users"
 RESET_TOKEN_VALIDITY_HOURS = 1
 
 @service()
-async def initiate_password_reset(username: str, is_admin_reset: bool = False, context=None) -> str:
+async def initiate_password_reset(username: str, is_admin_reset: bool = False, token: Optional[str] = None, context=None) -> str:
     """Initiates a password reset, generates a token, and stores it."""
+    # Log current working directory and absolute paths
+    cwd = os.getcwd()
+    abs_user_data_root = os.path.abspath(USER_DATA_ROOT)
     user_dir = os.path.join(USER_DATA_ROOT, username)
+    abs_user_dir = os.path.abspath(user_dir)
+    
+    logger.info(f"=== PASSWORD RESET INITIATION ===")
+    logger.info(f"Current working directory: {cwd}")
+    logger.info(f"USER_DATA_ROOT (relative): {USER_DATA_ROOT}")
+    logger.info(f"USER_DATA_ROOT (absolute): {abs_user_data_root}")
+    logger.info(f"User directory (relative): {user_dir}")
+    logger.info(f"User directory (absolute): {abs_user_dir}")
+    logger.info(f"Initiating password reset for user: {username}")
+    
     if not os.path.exists(user_dir):
+        logger.error(f"User directory not found: {user_dir} (absolute: {abs_user_dir})")
+        logger.error(f"Directory exists check: {os.path.exists(abs_user_dir)}")
         raise ValueError("User not found")
 
-    token = secrets.token_urlsafe(32)
+    # List existing files in user directory
+    try:
+        existing_files = os.listdir(user_dir)
+        logger.info(f"Existing files in user directory: {existing_files}")
+    except Exception as e:
+        logger.error(f"Error listing user directory: {e}")
+
+    if token is None:
+        token = secrets.token_urlsafe(32)
+    
     expires_at = datetime.utcnow() + timedelta(hours=RESET_TOKEN_VALIDITY_HOURS)
+    logger.info(f"Generated reset token for {username}, expires at: {expires_at.isoformat()}")
 
     reset_data = PasswordResetToken(
         token=token,
@@ -26,54 +55,178 @@ async def initiate_password_reset(username: str, is_admin_reset: bool = False, c
     )
 
     reset_file_path = os.path.join(user_dir, "password_reset.json")
+    abs_reset_file_path = os.path.abspath(reset_file_path)
+    logger.info(f"Saving reset token to: {reset_file_path} (absolute: {abs_reset_file_path})")
+    
     with open(reset_file_path, 'w') as f:
         json.dump(reset_data.dict(), f, indent=2)
-
-    # In a real application, you would email this token to the user.
-    # For this implementation, we return it directly.
+    
+    logger.info(f"Reset token file created successfully")
+    
+    # Verify file was created
+    if os.path.exists(reset_file_path):
+        logger.info(f"Verified: Reset token file exists after creation")
+        try:
+            with open(reset_file_path, 'r') as f:
+                verify_data = json.load(f)
+                logger.info(f"Verified: Reset token file contents: {verify_data}")
+        except Exception as e:
+            logger.error(f"Error reading back reset token file: {e}")
+    else:
+        logger.error(f"ERROR: Reset token file was not created successfully!")
+    
     return token
 
 @service()
 async def reset_password_with_token(token: str, new_password: str, context=None) -> bool:
     """Resets a user's password using a valid reset token."""
-    for username in os.listdir(USER_DATA_ROOT):
+    # Log current working directory and absolute paths
+    cwd = os.getcwd()
+    abs_user_data_root = os.path.abspath(USER_DATA_ROOT)
+    
+    logger.info(f"=== PASSWORD RESET ATTEMPT ===")
+    logger.info(f"Current working directory: {cwd}")
+    logger.info(f"USER_DATA_ROOT (relative): {USER_DATA_ROOT}")
+    logger.info(f"USER_DATA_ROOT (absolute): {abs_user_data_root}")
+    logger.info(f"Attempting password reset with token: {token[:10]}...{token[-10:]}")
+    logger.info(f"Token length: {len(token)}")
+    
+    if not os.path.exists(USER_DATA_ROOT):
+        logger.error(f"USER_DATA_ROOT directory does not exist:")
+        logger.error(f"  Relative path: {USER_DATA_ROOT}")
+        logger.error(f"  Absolute path: {abs_user_data_root}")
+        logger.error(f"  Exists check: {os.path.exists(abs_user_data_root)}")
+        raise ValueError("User data directory not found")
+    
+    users_found = 0
+    tokens_checked = 0
+    
+    try:
+        user_dirs = os.listdir(USER_DATA_ROOT)
+        logger.info(f"Found {len(user_dirs)} potential user directories: {user_dirs}")
+    except Exception as e:
+        logger.error(f"Error listing USER_DATA_ROOT: {e}")
+        raise ValueError("Error accessing user data")
+    
+    for username in user_dirs:
         user_dir = os.path.join(USER_DATA_ROOT, username)
+        abs_user_dir = os.path.abspath(user_dir)
+        logger.info(f"Checking user directory: {user_dir} (absolute: {abs_user_dir})")
+        
+        if not os.path.isdir(user_dir):
+            logger.debug(f"Skipping {username} - not a directory")
+            continue
+            
+        users_found += 1
+        
+        # List all files in this user directory
+        try:
+            user_files = os.listdir(user_dir)
+            logger.info(f"Files in user '{username}' directory: {user_files}")
+        except Exception as e:
+            logger.error(f"Error listing files in user directory {username}: {e}")
+            continue
+        
         reset_file_path = os.path.join(user_dir, "password_reset.json")
+        abs_reset_file_path = os.path.abspath(reset_file_path)
+        logger.info(f"Looking for reset file: {reset_file_path} (absolute: {abs_reset_file_path})")
+        logger.info(f"Reset file exists: {os.path.exists(reset_file_path)}")
 
         if not os.path.exists(reset_file_path):
+            logger.info(f"No reset file found for user {username} - skipping")
+            continue
+
+        logger.info(f"Found reset file for user {username}, reading token data")
+        
+        try:
+            with open(reset_file_path, 'r') as f:
+                reset_data_dict = json.load(f)
+                logger.info(f"Reset file contents for {username}: {reset_data_dict}")
+                reset_data = PasswordResetToken(**reset_data_dict)
+        except (json.JSONDecodeError, TypeError, ValueError) as e:
+            logger.error(f"Error parsing reset file for {username}: {e}")
+            continue
+        except Exception as e:
+            logger.error(f"Unexpected error reading reset file for {username}: {e}")
             continue
 
-        with open(reset_file_path, 'r') as f:
+        tokens_checked += 1
+        stored_token = reset_data.token
+        logger.info(f"Comparing tokens for user {username}:")
+        logger.info(f"  Provided token: '{token[:10]}...{token[-10:]}' (length: {len(token)})")
+        logger.info(f"  Stored token:   '{stored_token[:10]}...{stored_token[-10:]}' (length: {len(stored_token)})")
+        logger.info(f"  Tokens match: {stored_token == token}")
+        
+        # Also check for URL encoding issues
+        import urllib.parse
+        decoded_token = urllib.parse.unquote(token)
+        logger.info(f"  URL decoded token: '{decoded_token[:10]}...{decoded_token[-10:]}' (length: {len(decoded_token)})")
+        logger.info(f"  Decoded tokens match: {stored_token == decoded_token}")
+        
+        if reset_data.token == token or reset_data.token == decoded_token:
+            logger.info(f"Token match found for user {username}!")
+            matched_token = token if reset_data.token == token else decoded_token
+            logger.info(f"Matched using {'original' if matched_token == token else 'URL-decoded'} token")
+            
+            # Check expiration
             try:
-                reset_data = PasswordResetToken(**json.load(f))
-            except (json.JSONDecodeError, TypeError):
+                expires_at = datetime.fromisoformat(reset_data.expires_at)
+                current_time = datetime.utcnow()
+                logger.info(f"Token expires at: {expires_at}")
+                logger.info(f"Current time: {current_time}")
+                logger.info(f"Token expired: {expires_at < current_time}")
+                
+                if expires_at < current_time:
+                    logger.warning(f"Token expired for user {username}, removing reset file")
+                    os.remove(reset_file_path)
+                    raise ValueError("Password reset token has expired.")
+            except ValueError as e:
+                if "expired" in str(e):
+                    raise
+                logger.error(f"Error parsing expiration date for {username}: {e}")
                 continue
 
-        if reset_data.token == token:
-            if datetime.fromisoformat(reset_data.expires_at) < datetime.utcnow():
-                os.remove(reset_file_path) # Expired token
-                raise ValueError("Password reset token has expired.")
-
+            # Update password
             auth_file_path = os.path.join(user_dir, "auth.json")
+            abs_auth_file_path = os.path.abspath(auth_file_path)
+            logger.info(f"Updating password for user {username}")
+            logger.info(f"Auth file: {auth_file_path} (absolute: {abs_auth_file_path})")
+            
             if not os.path.exists(auth_file_path):
+                logger.error(f"Auth file not found for user {username}: {auth_file_path}")
                 os.remove(reset_file_path)
                 raise FileNotFoundError("User auth file not found.")
 
-            with open(auth_file_path, 'r+') as auth_file:
-                auth_data_dict = json.load(auth_file)
-                auth_data = UserAuth(**auth_data_dict)
-
-                new_password_hash = bcrypt.hashpw(new_password.encode(), bcrypt.gensalt()).decode()
-                auth_data.password_hash = new_password_hash
+            try:
+                with open(auth_file_path, 'r+') as auth_file:
+                    auth_data_dict = json.load(auth_file)
+                    auth_data = UserAuth(**auth_data_dict)
 
-                if reset_data.is_admin_reset and 'admin' not in auth_data.roles:
-                    auth_data.roles.append('admin')
+                    new_password_hash = bcrypt.hashpw(new_password.encode(), bcrypt.gensalt()).decode()
+                    auth_data.password_hash = new_password_hash
+                    logger.info(f"Password hash updated for user {username}")
 
-                auth_file.seek(0)
-                json.dump(auth_data.dict(), auth_file, indent=2, default=str)
-                auth_file.truncate()
+                    if reset_data.is_admin_reset and 'admin' not in auth_data.roles:
+                        auth_data.roles.append('admin')
+                        logger.info(f"Added admin role to user {username}")
 
-            os.remove(reset_file_path) # Invalidate token after use
-            return True
+                    auth_file.seek(0)
+                    json.dump(auth_data.dict(), auth_file, indent=2, default=str)
+                    auth_file.truncate()
+                    logger.info(f"Auth file updated for user {username}")
 
+                os.remove(reset_file_path)
+                logger.info(f"Reset token file removed for user {username}")
+                logger.info(f"Password reset completed successfully for user {username}")
+                return True
+                
+            except Exception as e:
+                logger.error(f"Error updating auth file for user {username}: {e}")
+                raise ValueError(f"Error updating user authentication: {e}")
+
+    logger.warning(f"=== TOKEN NOT FOUND ===")
+    logger.warning(f"Token not found after checking {users_found} users and {tokens_checked} tokens")
+    logger.warning(f"Provided token: '{token}'")
+    logger.warning(f"Current working directory: {cwd}")
+    logger.warning(f"Searched in: {abs_user_data_root}")
     raise ValueError("Invalid password reset token.")

mindroot/coreplugins/user_service/router.py

@@ -1,36 +1,98 @@
 from fastapi import APIRouter, Request, Form, Depends
 from fastapi.responses import HTMLResponse, RedirectResponse
 from lib.templates import render
+import os
+import json
+import logging
+# Import services directly to avoid coroutine-call confusion
 from .password_reset_service import reset_password_with_token, initiate_password_reset
 from lib.providers.services import service_manager
 from lib.providers import ProviderManager
+from lib.route_decorators import public_route
 
+logger = logging.getLogger(__name__)
 router = APIRouter()
 
-@router.get("/reset-password/{token}")
-async def get_reset_password_form(request: Request, token: str):
-    return await render('reset_password', {"request": request, "token": token, "error": None, "success": False})
+@public_route()
+@router.get("/reset-password/{filename}")
+async def get_reset_password_form_by_file(request: Request, filename: str):
+    """Show password reset form if trigger file exists"""
+    # print the current working directory
+    print("Current working directory:", os.getcwd())
+    trigger_dir = "data/password_resets"
+    file_path = os.path.join(trigger_dir, f"{filename}")
+    print("file path", file_path)
 
-@router.post("/reset-password/{token}")
-async def handle_reset_password(request: Request, token: str, password: str = Form(...), confirm_password: str = Form(...), services: ProviderManager = Depends(lambda: service_manager)):
-    if password != confirm_password:
-        return await render('reset_password', {"request": request, "token": token, "error": "Passwords do not match.", "success": False})
+    # Validate filename format
+    if not filename  or not filename.replace('-', '').replace('_', '').isalnum():
+        print('1')
+        html = await render('reset_password', {"request": request, "token": filename, "error": "Invalid file format", "success": False})
+        return HTMLResponse(content=html)
+    
+    if not os.path.exists(file_path) or not os.path.isfile(file_path):
+        print('2')
+        html = await render('reset_password', {"request": request, "token": filename, "error": "Reset file not found or expired", "success": False})
+        return HTMLResponse(content=html)
+    
+    # File exists and is actually a file, show the form
+    html = await render('reset_password', {"request": request, "token": filename, "error": None, "success": False})
+    return HTMLResponse(content=html)
 
+@public_route()
+@router.post("/reset-password/{filename}")
+async def handle_reset_password_by_file(request: Request, filename: str, password: str = Form(...), confirm_password: str = Form(...), services: ProviderManager = Depends(lambda: service_manager)):
+    """Handle password reset using trigger file"""
+    trigger_dir = "data/password_resets"
+    file_path = os.path.join(trigger_dir, f"{filename}")
+    
+    # Validate filename format
+    if not filename or not filename.replace('-', '').replace('_', '').isalnum():
+        html = await render('reset_password', {"request": request, "token": filename, "error": "Invalid file format", "success": False})
+        return HTMLResponse(content=html)
+    
+    if password != confirm_password:
+        html = await render('reset_password', {"request": request, "token": filename, "error": "Passwords do not match.", "success": False})
+        return HTMLResponse(content=html)
+    
+    if not os.path.exists(file_path) or not os.path.isfile(file_path):
+        html = await render('reset_password', {"request": request, "token": filename, "error": "Reset file not found or expired.", "success": False})
+        return HTMLResponse(content=html)
+    
     try:
-        success = await services.get('user_service.reset_password_with_token')(token=token, new_password=password)
+        # Read the trigger file
+        with open(file_path, 'r') as f:
+            data = f.read().strip()
+        
+        # Parse the file content: "username is_admin_reset"
+        parts = data.split(' ')
+        if len(parts) != 2:
+            html = await render('reset_password', {"request": request, "token": filename, "error": "Invalid reset file format.", "success": False})
+            return HTMLResponse(content=html)
+        
+        username, is_admin_reset_str = parts
+        is_admin_reset = is_admin_reset_str.lower() == 'true'
+        
+        if not username:
+            html = await render('reset_password', {"request": request, "token": filename, "error": "Invalid reset file format.", "success": False})
+            return HTMLResponse(content=html)
+        
+        logger.info(f"Processing password reset for user: {username} from file: {filename}")
+        
+        # Generate token and reset password
+        token = await initiate_password_reset(username=username, is_admin_reset=is_admin_reset)
+        success = await reset_password_with_token(token=token, new_password=password)
+        
         if success:
-            return await render('reset_password', {"request": request, "token": token, "error": None, "success": True})
+            # Delete the trigger file
+            os.remove(file_path)
+            logger.info(f"Successfully reset password for {username}, removed trigger file: {filename}")
+            html = await render('reset_password', {"request": request, "token": filename, "error": None, "success": True})
+            return HTMLResponse(content=html)
         else:
-            return await render('reset_password', {"request": request, "token": token, "error": "Invalid or expired token.", "success": False})
-    except ValueError as e:
-        return await render('reset_password', {"request": request, "token": token, "error": str(e), "success": False})
-
-# This is an admin-only function to generate a reset link.
-# In a real app, this would be more protected.
-@router.get("/admin/initiate-reset/{username}")
-async def admin_initiate_reset(username: str, services: ProviderManager = Depends(lambda: service_manager)):
-    try:
-        token = await services.get('user_service.initiate_password_reset')(username=username)
-        return HTMLResponse(f'<h1>Password Reset Link</h1><p>Share this link with the user: <a href="/user_service/reset-password/{token}">/user_service/reset-password/{token}</a></p>')
-    except ValueError as e:
-        return HTMLResponse(f'<h1>Error</h1><p>{str(e)}</p>', status_code=404)
+            html = await render('reset_password', {"request": request, "token": filename, "error": "Password reset failed.", "success": False})
+            return HTMLResponse(content=html)
+            
+    except Exception as e:
+        logger.error(f"Error processing trigger file {filename}: {e}")
+        html = await render('reset_password', {"request": request, "token": filename, "error": f"Error processing reset: {str(e)}", "success": False})
+        return HTMLResponse(content=html)

mindroot/lib/auth/api_key.py

@@ -0,0 +1,28 @@
+from typing import Optional, Dict
+
+async def verify_api_key(api_key: str) -> Optional[Dict]:
+    """
+    Verify an API key and return user data if valid.
+    
+    Args:
+        api_key: The API key to verify
+        
+    Returns:
+        Dict containing user data if valid, None otherwise
+    """
+    try:
+        # Import here to avoid circular imports
+        from mindroot.coreplugins.api_keys.api_key_manager import api_key_manager
+        
+        key_data = api_key_manager.validate_key(api_key)
+        if key_data:
+            return {
+                'username': key_data['username'],
+                'api_key': api_key,
+                'created_at': key_data['created_at'],
+                'description': key_data.get('description', '')
+            }
+        return None
+    except Exception as e:
+        print(f"Error verifying API key: {e}")
+        return None

mindroot/lib/cli/plugins.py

@@ -0,0 +1,94 @@
+import sys
+import os
+import asyncio
+from termcolor import colored
+from ..plugins.installation import download_github_files
+from ..plugins.manifest import update_plugin_manifest
+
+async def _stream_subprocess(cmd):
+    process = await asyncio.create_subprocess_exec(
+        *cmd,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE
+    )
+
+    async def read_stream(stream, prefix):
+        while True:
+            line = await stream.readline()
+            if line:
+                print(f"{prefix}{line.decode().strip()}")
+            else:
+                break
+
+    await asyncio.gather(
+        read_stream(process.stdout, ''),
+        read_stream(process.stderr, colored('ERR: ', 'red'))
+    )
+
+    await process.wait()
+    return process.returncode
+
+async def install_plugins_from_cli(plugin_sources: list, reinstall: bool = False):
+    """
+    Install plugins from the command line, streaming output.
+    """
+    print(colored(f"Attempting to install {len(plugin_sources)} plugins...", "cyan"))
+    results = []
+
+    for plugin_source in plugin_sources:
+        plugin_name = plugin_source.split('/')[-1]
+        print(colored(f"\n=== Installing {plugin_name} ===", "yellow"))
+
+        try:
+            if not reinstall:
+                import pkg_resources
+                try:
+                    pkg_resources.get_distribution(plugin_name)
+                    print(colored(f"{plugin_name} is already installed. Use --reinstall to update or force.", "green"))
+                    results.append({"plugin": plugin_name, "status": "already_installed"})
+                    continue
+                except pkg_resources.DistributionNotFound:
+                    pass # Not installed, proceed
+
+            if '/' in plugin_source:  # GitHub source
+                print(f"Installing from GitHub: {plugin_source}")
+                plugin_dir, _, plugin_info = download_github_files(plugin_source)
+                cmd = [sys.executable, '-m', 'pip', 'install', '-e', plugin_dir]
+                if reinstall:
+                    cmd.append('--force-reinstall')
+                return_code = await _stream_subprocess(cmd)
+
+                if return_code == 0:
+                    print(colored(f"Successfully installed {plugin_name} from {plugin_source}", "green"))
+                    update_plugin_manifest(
+                        plugin_info['name'],
+                        'github',
+                        os.path.abspath(plugin_dir),
+                        remote_source=plugin_source,
+                        version=plugin_info.get('version', '0.0.1'),
+                        metadata=plugin_info
+                    )
+                    results.append({"plugin": plugin_name, "status": "success", "source": "github"})
+                else:
+                    raise Exception(f"pip install failed with exit code {return_code}")
+
+            else:  # PyPI source
+                print(f"Installing from PyPI: {plugin_name}")
+                cmd = [sys.executable, '-m', 'pip', 'install', plugin_name]
+                if reinstall:
+                    cmd.extend(['--upgrade', '--force-reinstall'])
+                return_code = await _stream_subprocess(cmd)
+
+                if return_code == 0:
+                    print(colored(f"Successfully installed {plugin_name} from PyPI", "green"))
+                    update_plugin_manifest(plugin_name, 'pypi', None)
+                    results.append({"plugin": plugin_name, "status": "success", "source": "pypi"})
+                else:
+                    raise Exception(f"pip install failed with exit code {return_code}")
+
+        except Exception as e:
+            print(colored(f"ERROR: Failed to install {plugin_name}: {str(e)}", "red"))
+            results.append({"plugin": plugin_name, "status": "error", "message": str(e)})
+
+    print(colored("\nPlugin installation process finished.", "cyan"))
+    # You can optionally print a summary of results here

mindroot/lib/plugins/default_plugin_manifest.json

@@ -21,10 +21,18 @@
         "enabled": true,
         "source": "core"
       },
+      "l8n": {
+        "enabled": true,
+        "source": "core"
+      },
       "jwt_auth": {
         "enabled": true,
         "source": "core"
       },
+      "mcp_": {
+        "enabled": true,
+        "source": "core"
+      },
       "api_keys": {
         "enabled": true,
         "source": "core"
@@ -45,6 +53,14 @@
         "enabled": true,
         "source": "core"
       },
+      "signup": {
+        "enabled": true,
+        "source": "core"
+      },
+      "email": {
+        "enabled": true,
+        "source": "core"
+      },
       "user_service": {
         "enabled": true,
         "source": "core"
@@ -65,6 +81,10 @@
           "enabled": false,
           "source": "core"
       },
+      "subscriptions": {
+        "enabled": false,
+        "source": "core"
+      },
       "startup": {
         "enabled": true,
         "source": "core"

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