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

mindroot/coreplugins/mcp_/test_dynamic_commands.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+"""
+Test script to verify dynamic command registration for both uvx and npx MCP servers
+"""
+
+import asyncio
+import sys
+import os
+
+# Add the mindroot lib to path
+sys.path.insert(0, '/files/mindroot/src/mindroot')
+
+from .mod import mcp_manager, MCPServer
+from src.mr_mcp.dynamic_commands import MCPDynamicCommands
+from lib.providers.commands import command_manager
+
+async def test_dynamic_command_registration():
+    print("Testing dynamic command registration for MCP servers...")
+    
+    # Check current registered commands
+    print(f"\nCurrently registered commands: {len(command_manager.functions)}")
+    mcp_commands = [name for name in command_manager.functions.keys() if name.startswith('mcp_')]
+    print(f"Current MCP commands: {mcp_commands}")
+    
+    # Test creating both uvx and npx servers
+    print("\n=== Testing UVX Server (Calculator) ===")
+    
+    uvx_server = EnhancedMCPServer(
+        name="test_calculator",
+        description="Test calculator server via uvx",
+        command="uvx",
+        args=["mcp-server-calculator"],
+        install_method="uvx",
+        install_package="mcp-server-calculator",
+        auto_install=True
+    )
+    
+    enhanced_mcp_manager.add_server("test_calculator", uvx_server)
+    print(f"Added uvx server: {uvx_server.name}")
+    print(f"Command: {uvx_server.command} {' '.join(uvx_server.args)}")
+    
+    print("\n=== Testing NPX Server (GitHub) ===")
+    
+    npx_server = EnhancedMCPServer(
+        name="test_github",
+        description="Test GitHub server via npx",
+        command="npx",
+        args=["-y", "@modelcontextprotocol/server-github"],
+        install_method="npx",
+        install_package="@modelcontextprotocol/server-github",
+        auto_install=True
+    )
+    
+    enhanced_mcp_manager.add_server("test_github", npx_server)
+    print(f"Added npx server: {npx_server.name}")
+    print(f"Command: {npx_server.command} {' '.join(npx_server.args)}")
+    
+    # Check if dynamic commands object is properly initialized
+    print(f"\n=== Dynamic Commands System ===")
+    print(f"Dynamic commands object: {enhanced_mcp_manager.dynamic_commands}")
+    print(f"Sessions reference set: {bool(enhanced_mcp_manager.dynamic_commands.sessions)}")
+    print(f"Registered dynamic commands: {enhanced_mcp_manager.dynamic_commands.get_registered_commands()}")
+    
+    # Test the registration process manually
+    print("\n=== Manual Tool Registration Test ===")
+    
+    # Create a mock tool object
+    class MockTool:
+        def __init__(self, name, description):
+            self.name = name
+            self.description = description
+            self.inputSchema = {
+                "type": "object",
+                "properties": {
+                    "expression": {
+                        "type": "string",
+                        "description": "Mathematical expression to evaluate"
+                    }
+                },
+                "required": ["expression"]
+            }
+    
+    mock_tools = [MockTool("calculate", "Perform mathematical calculations")]
+    
+    print("Testing tool registration for mock calculator...")
+    await enhanced_mcp_manager.dynamic_commands.register_tools("test_calculator", mock_tools)
+    
+    # Check if command was registered
+    expected_cmd = "mcp_test_calculator_calculate"
+    if expected_cmd in command_manager.functions:
+        print(f"✅ SUCCESS: Command {expected_cmd} was registered!")
+        cmd_info = command_manager.functions[expected_cmd]
+        if hasattr(cmd_info, 'docstring'):
+            print(f"   Docstring: {cmd_info.docstring[:100]}...")
+        else:
+            print(f"   Command info: {type(cmd_info)}")
+    else:
+        print(f"❌ FAILED: Command {expected_cmd} was not registered")
+        print(f"   Available commands: {list(command_manager.functions.keys())[-5:]}")
+    
+    # Test with npx server
+    print("\nTesting tool registration for mock GitHub server...")
+    
+    github_tools = [MockTool("create_repository", "Create a new GitHub repository")]
+    await enhanced_mcp_manager.dynamic_commands.register_tools("test_github", github_tools)
+    
+    expected_cmd2 = "mcp_test_github_create_repository"
+    if expected_cmd2 in command_manager.functions:
+        print(f"✅ SUCCESS: Command {expected_cmd2} was registered!")
+    else:
+        print(f"❌ FAILED: Command {expected_cmd2} was not registered")
+    
+    # Final summary
+    print(f"\n=== Final Summary ===")
+    final_mcp_commands = [name for name in command_manager.functions.keys() if name.startswith('mcp_')]
+    print(f"Total MCP commands now: {len(final_mcp_commands)}")
+    print(f"Dynamic commands: {[cmd for cmd in final_mcp_commands if 'test_' in cmd]}")
+    
+    print("\n=== Conclusion ===")
+    print("The dynamic command registration system works the same for both uvx and npx servers.")
+    print("The issue you're experiencing might be:")
+    print("1. The MCP server isn't actually connecting successfully")
+    print("2. The server doesn't expose tools (some servers only have resources/prompts)")
+    print("3. There's an error during the connection process")
+    print("4. The admin interface cache needs to be refreshed")
+    
+    print("\nTo debug further:")
+    print("1. Check the server logs when connecting")
+    print("2. Verify the server actually starts and responds")
+    print("3. Check if the server exposes tools vs just resources")
+    print("4. Try refreshing the admin interface after connection")
+
+if __name__ == "__main__":
+    asyncio.run(test_dynamic_command_registration())

mindroot/coreplugins/mcp_/testmcpclient.py

@@ -0,0 +1,92 @@
+"""
+Before running, specify running MCP RS server URL.
+To spin up RS server locally, see
+    examples/servers/simple-auth/README.md
+
+cd to the `examples/snippets` directory and run:
+    uv run oauth-client
+"""
+
+import asyncio
+from urllib.parse import parse_qs, urlparse
+
+from pydantic import AnyUrl
+
+from mcp import ClientSession
+from mcp.client.auth import OAuthClientProvider, TokenStorage
+from mcp.client.streamable_http import streamablehttp_client
+from mcp.shared.auth import OAuthClientInformationFull, OAuthClientMetadata, OAuthToken
+
+
+class InMemoryTokenStorage(TokenStorage):
+    """Demo In-memory token storage implementation."""
+
+    def __init__(self):
+        self.tokens: OAuthToken | None = None
+        self.client_info: OAuthClientInformationFull | None = None
+
+    async def get_tokens(self) -> OAuthToken | None:
+        """Get stored tokens."""
+        return self.tokens
+
+    async def set_tokens(self, tokens: OAuthToken) -> None:
+        """Store tokens."""
+        self.tokens = tokens
+
+    async def get_client_info(self) -> OAuthClientInformationFull | None:
+        """Get stored client information."""
+        return self.client_info
+
+    async def set_client_info(self, client_info: OAuthClientInformationFull) -> None:
+        """Store client information."""
+        self.client_info = client_info
+
+
+async def handle_redirect(auth_url: str) -> None:
+    print(f"Visit: {auth_url}")
+
+
+async def handle_callback() -> tuple[str, str | None]:
+    callback_url = input("Paste callback URL: ")
+    params = parse_qs(urlparse(callback_url).query)
+    print("Callback URL parameters:")
+    print(params)
+    return params["code"][0], params.get("state", [None])[0]
+
+
+async def main():
+    """Run the OAuth client example."""
+    oauth_auth = OAuthClientProvider(
+        server_url="https://mcp.notion.com",
+        client_metadata=OAuthClientMetadata(
+            client_name="Example MCP Client",
+            redirect_uris=[AnyUrl("http://localhost:3000/callback")],
+            grant_types=["authorization_code", "refresh_token"],
+            response_types=["code"],
+            scope="user",
+        ),
+        storage=InMemoryTokenStorage(),
+        redirect_handler=handle_redirect,
+        callback_handler=handle_callback,
+    )
+
+    print("Starting.")
+    async with streamablehttp_client("https://mcp.notion.com/sse", auth=oauth_auth) as (read, write, _):
+        print("1")
+        async with ClientSession(read, write) as session:
+            print("2")
+            await session.initialize()
+            print("3")
+            tools = await session.list_tools()
+            print(f"Available tools: {[tool.name for tool in tools.tools]}")
+
+            resources = await session.list_resources()
+            print(f"Available resources: {[r.uri for r in resources.resources]}")
+
+
+def run():
+    asyncio.run(main())
+
+
+if __name__ == "__main__":
+    run()

mindroot/coreplugins/persona/mod.py

@@ -12,15 +12,20 @@ from .init_persona import *
 @service()
 async def get_persona_data(persona_name, context=None):
     print("persona name is", persona_name, file=sys.stderr)
-    # use pwd as base dir
-    # current working dir of process 
     pwd = os.getcwd()
-    persona_path = os.path.join(pwd, 'personas', 'local', persona_name)
-    if not os.path.exists(persona_path):
-        persona_path = os.path.join(pwd, 'personas', 'shared', persona_name)
+    
+    # Handle registry personas: registry/owner/name
+    if persona_name.startswith('registry/'):
+        persona_path = os.path.join(pwd, 'personas', persona_name)
+    else:
+        # Legacy support: check local first, then shared
+        persona_path = os.path.join(pwd, 'personas', 'local', persona_name)
         if not os.path.exists(persona_path):
-            # need to raise an error here
-            raise Exception(f"Persona {persona_name} not found in {persona_path}")
+            persona_path = os.path.join(pwd, 'personas', 'shared', persona_name)
+    
+    if not os.path.exists(persona_path):
+        # need to raise an error here
+        raise Exception(f"Persona {persona_name} not found in {persona_path}")
 
     # read the persona data
     # use blue background and yellow text

mindroot/coreplugins/signup/templates/signup.jinja2

@@ -130,7 +130,7 @@
 <body>
     <div class="signup-container">
         <div class="logo-container">
-            <img src="/home/static/imgs/logo.png" alt="MindRoot Logo" class="logo">
+            <img src="/imgs/logo.png" alt="MindRoot Logo" class="logo">
             <h1>Create Your MindRoot Account</h1>
         </div>
 

mindroot/coreplugins/subscriptions/__init__.py

@@ -3,3 +3,4 @@ import asyncio
 
 # Import all services and commands
 from .mod import *
+

mindroot/coreplugins/subscriptions/mod.py

@@ -266,7 +266,6 @@ async def get_available_features(active_only: bool = True, context=None) -> List
     
     features = await _subscription_manager.storage.get_all_features(active_only)
     return [feature.to_dict() for feature in features]
-
 @service()
 async def create_plan_feature(feature_data: Dict[str, Any], context=None) -> Dict[str, Any]:
     """Create a new plan feature
@@ -549,6 +548,19 @@ async def process_subscription_event(event_data: Dict[str, Any], context=None) -
                 }
             )
             
+            # Notify any plugins that handle subscription creation
+            try:
+                from lib.providers.services import service_manager
+                await service_manager.handle_subscription_created(
+                    user_id=username,
+                    subscription_id=subscription.subscription_id,
+                    plan_id=plan_id,
+                    metadata=metadata
+                )
+                logger.info(f"Notified subscription handlers for {username}")
+            except Exception as e:
+                logger.error(f"Failed to notify subscription handlers: {e}")
+            
             return {
                 'status': 'success',
                 'event_type': event_type,
@@ -558,7 +570,6 @@ async def process_subscription_event(event_data: Dict[str, Any], context=None) -
         else:
             logger.error(f"Plan not found: {plan_id}")
             return {'status': 'error', 'message': f"Plan not found: {plan_id}"}
-    
     elif event_type == 'subscription_renewed':
         # Handle subscription renewal
         provider_subscription_id = normalized_event.get('subscription_id')
@@ -840,4 +851,4 @@ async def get_my_subscriptions(params, context=None):
         
         result += "\n"
     
-    return result
+    return result

mindroot/coreplugins/subscriptions/router.py

@@ -235,7 +235,9 @@ async def api_create_checkout(plan_id: str,
                             provider: str = Query('stripe')):
     """Create checkout session for subscription"""
     try:
+        print("checkout")
         if not request.state.user:
+            print("Unauthorized")
             raise UNAUTHORIZED
             
         username = request.state.user.username
@@ -243,6 +245,7 @@ async def api_create_checkout(plan_id: str,
         # Get plan details
         plan = await get_subscription_plan(plan_id, context=request)
         if not plan:
+            print("could not find plan",plan_id)
             raise NOT_FOUND
         
         # Call provider-specific checkout service

mindroot/coreplugins/user_service/__init__.py

@@ -6,5 +6,4 @@ from .admin_init import *
 
 from .password_reset_service import *
 from .router import router
-from .file_trigger_service import *
-from .hooks import *
+

mindroot/coreplugins/user_service/admin_init.py

@@ -93,6 +93,7 @@ async def initialize_admin(user_data_root: str, app) -> Tuple[Optional[str], Opt
         
         if not (username and password):
             username, password = generate_random_credentials()
+            username = 'admin'
             print("\n" + "="*50)
             print("INITIAL ADMIN CREDENTIALS GENERATED:")
             print(f"Username: {username}")

mindroot/coreplugins/user_service/email_service.py

@@ -1,33 +1,88 @@
-#from mindroot.coreplugins.email.mod import EmailMessage
 from lib.providers.services import service_manager
 from datetime import datetime, timedelta
 import secrets
 import os
+import logging
+
+logger = logging.getLogger(__name__)
 
 REQUIRE_EMAIL_VERIFY = os.environ.get('REQUIRE_EMAIL_VERIFY', '').lower() == 'true'
+BASE_URL = os.environ.get('BASE_URL', 'http://localhost:8011')
 
 async def send_verification_email(email: str, verification_token: str):
     """Send email verification link to user."""
-    verification_url = f"http://localhost:8011/verify-email?token={verification_token}"
+    verification_url = f"{BASE_URL}/verify-email?token={verification_token}"
+    
     email_html = f"""
-    <h1>Welcome to MindRoot!</h1>
-    <p>Please verify your email address by clicking the link below:</p>
-    <p><a href="{verification_url}">{verification_url}</a></p>
-    <p>This link will expire in 24 hours.</p>
-    <br>
-    <p>If you did not create this account, please ignore this email.</p>
+    <html>
+    <body>
+        <h1>Welcome to MindRoot!</h1>
+        <p>Please verify your email address by clicking the link below:</p>
+        <p><a href="{verification_url}" style="background-color: #4CAF50; color: white; padding: 10px 20px; text-decoration: none; border-radius: 4px;">Verify Email</a></p>
+        <p>Or copy and paste this link into your browser:</p>
+        <p><code>{verification_url}</code></p>
+        <p>This link will expire in 24 hours.</p>
+        <br>
+        <p><small>If you did not create this account, please ignore this email.</small></p>
+    </body>
+    </html>
     """
-    print("Not implemented")
-    return False   
+    
     try:
-        #await service_manager.send_email(EmailMessage(
-        #    to=email,
-        #    subject="Verify Your MindRoot Account",
-        #    body=email_html
-        #))
-        return True
+        result = await service_manager.send_email(
+            to=email,
+            subject="Verify Your MindRoot Account",
+            body=email_html  # HTML content will be auto-detected
+        )
+        
+        if result.get('success'):
+            logger.info(f"Verification email sent successfully to {email}")
+            return True
+        else:
+            logger.error(f"Failed to send verification email to {email}: {result.get('error')}")
+            return False
+            
+    except Exception as e:
+        logger.error(f"Exception sending verification email to {email}: {e}")
+        return False
+
+async def send_password_reset_email(email: str, username: str, reset_token: str):
+    """Send password reset email to user."""
+    reset_url = f"{BASE_URL}/reset-password?token={reset_token}"
+    
+    email_html = f"""
+    <html>
+    <body>
+        <h1>Password Reset Request</h1>
+        <p>Hello {username},</p>
+        <p>You have requested to reset your password for your MindRoot account.</p>
+        <p>Click the link below to reset your password:</p>
+        <p><a href="{reset_url}" style="background-color: #f44336; color: white; padding: 10px 20px; text-decoration: none; border-radius: 4px;">Reset Password</a></p>
+        <p>Or copy and paste this link into your browser:</p>
+        <p><code>{reset_url}</code></p>
+        <p>This link will expire in 1 hour.</p>
+        <br>
+        <p><small>If you did not request this password reset, please ignore this email.</small></p>
+    </body>
+    </html>
+    """
+    
+    try:
+        result = await service_manager.send_email(
+            to=email,
+            subject="Password Reset Request - MindRoot",
+            body=email_html  # HTML content will be auto-detected
+        )
+        
+        if result.get('success'):
+            logger.info(f"Password reset email sent successfully to {email}")
+            return True
+        else:
+            logger.error(f"Failed to send password reset email to {email}: {result.get('error')}")
+            return False
+            
     except Exception as e:
-        print(f"Warning: Could not send verification email: {e}")
+        logger.error(f"Exception sending password reset email to {email}: {e}")
         return False
 
 def setup_verification() -> tuple[str, str, bool]:

mindroot/coreplugins/user_service/mod.py

@@ -70,20 +70,28 @@ async def create_user(user_data: UserCreate, roles: List[str] = None, skip_verif
 async def verify_user(username: str, password: str, context=None) -> bool:
     """Verify user credentials and update last login"""
     auth_file = os.path.join(USER_DATA_ROOT, username, "auth.json")
-    
+        
     if not os.path.exists(auth_file):
+        print("user not found")
+        print("path", auth_file)
+        print("working dir", os.getcwd())
         return False
         
     with open(auth_file, 'r') as f:
         auth_data = UserAuth(**json.load(f))
     
     if bcrypt.checkpw(password.encode(), auth_data.password_hash.encode()):
+        print("check pw passed")
         # Update last login
         auth_data.last_login = datetime.utcnow().isoformat()
         with open(auth_file, 'w') as f:
             json.dump(auth_data.dict(), f, indent=2, default=str)
         return True
-    return False
+    else:
+        print("checkpw failed,")
+        print("auth_data", auth_data)
+        print("password:", password.encode())
+        return False
 
 
 @service()

mindroot/coreplugins/user_service/router.py

@@ -17,6 +17,8 @@ router = APIRouter()
 @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)

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"