mindroot 9.2.0__tar.gz → 9.3.0__tar.gz

{mindroot-9.2.0/src/mindroot.egg-info → mindroot-9.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mindroot
-Version: 9.2.0
+Version: 9.3.0
 Summary: MindRoot AI Agent Framework
 Requires-Python: >=3.9
 License-File: LICENSE

{mindroot-9.2.0 → mindroot-9.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mindroot"
-version = "9.2.0"
+version = "9.3.0"
 description = "MindRoot AI Agent Framework"
 requires-python = ">=3.9"
 dependencies = [

{mindroot-9.2.0 → mindroot-9.3.0}/src/mindroot/coreplugins/admin/plugin_router.py

@@ -21,7 +21,7 @@ def update_plugins(request: PluginUpdateRequest):
         with open('plugins.json', 'w') as file:
             json.dump(plugins_data, file, indent=2)
 
-        plugins.load('plugin_manifest.json')
+        plugins.load('data/plugin_manifest.json')
 
         return {"message": "Plugins updated successfully"}
     except Exception as e:

{mindroot-9.2.0 → mindroot-9.3.0}/src/mindroot/coreplugins/index/handlers/plugin_ops.py

@@ -12,7 +12,7 @@ logger = logging.getLogger(__name__)
 async def get_installed_plugin_metadata(plugin_name: str) -> dict:
     """Get metadata from main plugin manifest"""
     try:
-        manifest_path = Path('plugin_manifest.json')
+        manifest_path = Path('data/plugin_manifest.json')
         logger.debug(f"Reading main plugin manifest from: {manifest_path}")
         
         if not manifest_path.exists():

{mindroot-9.2.0 → mindroot-9.3.0}/src/mindroot/coreplugins/jwt_auth/middleware.py

@@ -142,7 +142,8 @@ async def middleware(request: Request, call_next):
             print("Error checking for static file", e)
             pass
         print("Did not find static file")
-        if request.url.path in public_routes:
+        # Accept explicitly-registered public routes, _or_ the password-reset link which carries its own token
+        if request.url.path in public_routes or request.url.path.startswith('/reset-password'):
             print('Public route: ', request.url.path)
             return await call_next(request)
         elif any([request.url.path.startswith(path) for path in public_static]):

mindroot-9.3.0/src/mindroot/coreplugins/user_service/file_trigger_service.py

@@ -0,0 +1,12 @@
+import asyncio
+import json
+import os
+import logging
+from datetime import datetime
+from lib.providers.services import service, ServiceProvider
+
+logger = logging.getLogger(__name__)
+
+# This file is kept for backward compatibility
+# Password reset trigger functionality is now handled directly in router.py
+logger.info("File trigger service loaded - functionality moved to router.py")

mindroot-9.3.0/src/mindroot/coreplugins/user_service/password_reset_service.py

@@ -0,0 +1,232 @@
+from typing import Optional
+from lib.providers.services import service
+from .models import UserAuth, PasswordResetToken
+import bcrypt
+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, 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")
+
+    # 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,
+        expires_at=expires_at.isoformat(),
+        is_admin_reset=is_admin_reset
+    )
+
+    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)
+    
+    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."""
+    # 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
+
+        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:
+                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
+
+            # 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.")
+
+            try:
+                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
+                    logger.info(f"Password hash updated for user {username}")
+
+                    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}")
+
+                    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-9.3.0/src/mindroot/coreplugins/user_service/router.py

@@ -0,0 +1,96 @@
+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()
+
+@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"""
+    trigger_dir = "data/password_resets"
+    file_path = os.path.join(trigger_dir, f"{filename}")
+    print("file path", file_path)
+
+    # 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:
+        # 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:
+            # 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:
+            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-9.2.0 → mindroot-9.3.0}/src/mindroot/lib/plugins/manifest.py

@@ -1,9 +1,10 @@
 import json
 import os
+import shutil
 from datetime import datetime
 
 # Central definition of manifest file location
-MANIFEST_FILE = 'plugin_manifest.json'
+MANIFEST_FILE = 'data/plugin_manifest.json'
 
 def load_plugin_manifest():
     """Load the plugin manifest file.
@@ -68,12 +69,20 @@ def update_plugin_manifest(plugin_name, source, source_path, remote_source=None,
 
 def create_default_plugin_manifest():
     """Create a new default manifest file."""
-    # read from default_plugin_manifest.json in same dir as this file
-    default_manifest_path = os.path.join(os.path.dirname(__file__), 'default_plugin_manifest.json')
-    with open(default_manifest_path, 'r') as f:
-        default_manifest = json.load(f)
-    save_plugin_manifest(default_manifest)
-
+    # First check if there's an existing manifest in the root directory
+    old_manifest_path = 'plugin_manifest.json'
+    if os.path.exists(old_manifest_path):
+        # Move existing manifest from root to data directory
+        os.makedirs(os.path.dirname(MANIFEST_FILE), exist_ok=True)
+        shutil.move(old_manifest_path, MANIFEST_FILE)
+    else:
+        # No existing manifest, create from default template
+        # read from default_plugin_manifest.json in same dir as this file
+        default_manifest_path = os.path.join(os.path.dirname(__file__), 'default_plugin_manifest.json')
+        with open(default_manifest_path, 'r') as f:
+            default_manifest = json.load(f)
+        os.makedirs(os.path.dirname(MANIFEST_FILE), exist_ok=True)
+        save_plugin_manifest(default_manifest)
 def toggle_plugin_state(plugin_name, enabled):
     """Toggle a plugin's enabled state.
     

mindroot-9.3.0/src/mindroot/migrate.py

@@ -0,0 +1,30 @@
+import os
+import shutil
+from pathlib import Path
+
+def migrate_plugin_manifest():
+    """Migrate plugin_manifest.json from root to data/ directory if needed."""
+    root_manifest = 'plugin_manifest.json'
+    data_manifest = 'data/plugin_manifest.json'
+    
+    # If the new location already exists, no migration needed
+    if os.path.exists(data_manifest):
+        print(f"Plugin manifest already exists at {data_manifest}")
+        return
+    
+    # If old location exists, move it to new location
+    if os.path.exists(root_manifest):
+        print(f"Migrating plugin manifest from {root_manifest} to {data_manifest}")
+        # Ensure data directory exists
+        os.makedirs('data', exist_ok=True)
+        # Move the file
+        shutil.move(root_manifest, data_manifest)
+        print(f"Plugin manifest migration complete")
+    else:
+        print("No existing plugin manifest found to migrate")
+
+def run_migrations():
+    """Run all necessary migrations."""
+    print("Running MindRoot migrations...")
+    migrate_plugin_manifest()
+    print("Migrations complete")

{mindroot-9.2.0 → mindroot-9.3.0}/src/mindroot/server.py

@@ -14,6 +14,7 @@ import socket
 from fastapi.middleware.cors import CORSMiddleware
 from starlette.middleware.base import BaseHTTPMiddleware
 from dotenv import load_dotenv
+from .migrate import run_migrations
 
 # Load environment variables from .env file at the start
 # Set override=True to make .env variables override existing environment variables
@@ -35,6 +36,7 @@ def get_project_root():
 def create_directories():
     root = get_project_root()
     directories = [
+        "data",
         "imgs",
         "models",
         "models/face",
@@ -102,6 +104,9 @@ class HeaderMiddleware(BaseHTTPMiddleware):
 
 def main():
     global app
+    
+    # Run migrations first, before anything else
+    run_migrations()
 
     cmd_args = parse_args()
     # save ALL parsed args in app state

{mindroot-9.2.0 → mindroot-9.3.0/src/mindroot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mindroot
-Version: 9.2.0
+Version: 9.3.0
 Summary: MindRoot AI Agent Framework
 Requires-Python: >=3.9
 License-File: LICENSE

{mindroot-9.2.0 → mindroot-9.3.0}/src/mindroot.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ MANIFEST.in
 README.md
 pyproject.toml
 src/mindroot/__init__.py
+src/mindroot/migrate.py
 src/mindroot/server.py
 src/mindroot.egg-info/PKG-INFO
 src/mindroot.egg-info/SOURCES.txt

mindroot-9.2.0/src/mindroot/coreplugins/user_service/file_trigger_service.py

@@ -1,72 +0,0 @@
-import asyncio
-import json
-import os
-import logging
-from datetime import datetime
-from lib.providers.services import service, ServiceProvider
-
-logger = logging.getLogger(__name__)
-
-# Use paths relative to the process working directory
-REQUEST_DIR = "data/password_resets/requests"
-GENERATED_DIR = "data/password_resets/generated"
-CHECK_INTERVAL_SECONDS = 30
-
-@service()
-async def process_password_reset_requests(context=None):
-    """Processes password reset request files from a directory."""
-    # Ensure directories exist
-    os.makedirs(REQUEST_DIR, exist_ok=True)
-    os.makedirs(GENERATED_DIR, exist_ok=True)
-
-    sp = ServiceProvider()
-    initiate_reset = sp.get('user_service.initiate_password_reset')
-    
-    if not (initiate_reset and callable(initiate_reset)):
-        logger.error("Could not get 'user_service.initiate_password_reset' service.")
-        return
-
-    for filename in os.listdir(REQUEST_DIR):
-        request_file_path = os.path.join(REQUEST_DIR, filename)
-        if not os.path.isfile(request_file_path):
-            continue
-
-        try:
-            with open(request_file_path, 'r') as f:
-                data = json.load(f)
-            
-            username = data.get("username")
-            is_admin_reset = data.get("is_admin_reset", False)
-
-            if not username:
-                raise ValueError("Username is missing from request file.")
-
-            logger.info(f"Processing password reset request for user: {username}")
-            token = await initiate_reset(username=username, is_admin_reset=is_admin_reset)
-            
-            reset_link = f"/user_service/reset-password/{token}"
-            generated_file_path = os.path.join(GENERATED_DIR, f"{username}_{datetime.utcnow().strftime('%Y%m%d%H%M%S')}.json")
-            with open(generated_file_path, 'w') as f:
-                json.dump({"username": username, "reset_link": reset_link, "token": token}, f, indent=2)
-            
-            logger.info(f"Successfully generated password reset link for {username}.")
-            os.remove(request_file_path)
-
-        except Exception as e:
-            logger.error(f"Failed to process reset request file {filename}: {e}")
-            error_file_path = os.path.join(REQUEST_DIR, f"{filename}.error")
-            os.rename(request_file_path, error_file_path)
-
-@service()
-async def start_file_watcher_service(context=None):
-    """Starts a background task to watch for password reset request files."""
-    logger.info("Starting password reset file watcher service.")
-    async def watcher_loop():
-        while True:
-            try:
-                await process_password_reset_requests()
-            except Exception as e:
-                logger.error(f"Error in password reset watcher loop: {e}")
-            await asyncio.sleep(CHECK_INTERVAL_SECONDS)
-    
-    asyncio.create_task(watcher_loop())

mindroot-9.2.0/src/mindroot/coreplugins/user_service/password_reset_service.py

@@ -1,79 +0,0 @@
-from lib.providers.services import service
-from .models import UserAuth, PasswordResetToken
-import bcrypt
-import json
-import os
-import secrets
-from datetime import datetime, timedelta
-
-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:
-    """Initiates a password reset, generates a token, and stores it."""
-    user_dir = os.path.join(USER_DATA_ROOT, username)
-    if not os.path.exists(user_dir):
-        raise ValueError("User not found")
-
-    token = secrets.token_urlsafe(32)
-    expires_at = datetime.utcnow() + timedelta(hours=RESET_TOKEN_VALIDITY_HOURS)
-
-    reset_data = PasswordResetToken(
-        token=token,
-        expires_at=expires_at.isoformat(),
-        is_admin_reset=is_admin_reset
-    )
-
-    reset_file_path = os.path.join(user_dir, "password_reset.json")
-    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.
-    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):
-        user_dir = os.path.join(USER_DATA_ROOT, username)
-        reset_file_path = os.path.join(user_dir, "password_reset.json")
-
-        if not os.path.exists(reset_file_path):
-            continue
-
-        with open(reset_file_path, 'r') as f:
-            try:
-                reset_data = PasswordResetToken(**json.load(f))
-            except (json.JSONDecodeError, TypeError):
-                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.")
-
-            auth_file_path = os.path.join(user_dir, "auth.json")
-            if not os.path.exists(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
-
-                if reset_data.is_admin_reset and 'admin' not in auth_data.roles:
-                    auth_data.roles.append('admin')
-
-                auth_file.seek(0)
-                json.dump(auth_data.dict(), auth_file, indent=2, default=str)
-                auth_file.truncate()
-
-            os.remove(reset_file_path) # Invalidate token after use
-            return True
-
-    raise ValueError("Invalid password reset token.")