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

mindroot/coreplugins/admin/mcp_routes.py

@@ -0,0 +1,216 @@
+from fastapi import APIRouter, HTTPException
+import os
+from pydantic import BaseModel
+from typing import Optional, List, Dict, Any
+from lib.route_decorators import requires_role
+
+# Import MCP components - prefer new mcp_ module, fallback to legacy if needed
+try:
+    from mindroot.coreplugins.mcp_.mod import mcp_manager, MCPServer
+except ImportError:
+    try:
+        from mindroot.coreplugins.mcp.mod import mcp_manager, MCPServer
+    except ImportError:
+        # Mock objects if MCP plugin is not fully installed, to prevent startup crash
+        mcp_manager = None
+        MCPServer = None
+
+# Create router with admin role requirement
+router = APIRouter(
+    dependencies=[requires_role('admin')]
+)
+
+class McpLocalTestRequest(BaseModel):
+    name: str
+    command: str
+    args: List[str] = []
+    env: Dict[str, str] = {}
+    secrets: Optional[Dict[str, str]] = None
+
+class McpServerRequest(BaseModel):
+    server_name: str
+
+class McpConnectRequest(BaseModel):
+    server_name: str
+    secrets: Optional[Dict[str, str]] = None
+
+class McpServerAddRequest(BaseModel):
+    name: str
+    description: str
+    command: Optional[str] = None
+    args: List[str] = []
+    env: dict = {}
+    transport: str = "stdio"
+    url: Optional[str] = None
+    # New URL fields
+    provider_url: Optional[str] = None
+    transport_url: Optional[str] = None
+    transport_type: Optional[str] = None  # "sse" | "streamable_http"
+    # OAuth 2.0 fields
+    auth_type: str = "none"
+    auth_headers: Dict[str, str] = {}
+    authorization_server_url: Optional[str] = None
+    client_id: Optional[str] = None
+    client_secret: Optional[str] = None
+    scopes: List[str] = []
+    redirect_uri: Optional[str] = None
+
+class McpOAuthCallbackRequest(BaseModel):
+    server_name: str
+    code: str
+    state: Optional[str] = None
+
+# --- MCP Server Management Routes ---
+
+@router.get("/mcp/list")
+async def list_mcp_servers():
+    """List all configured MCP servers."""
+    if not mcp_manager:
+        raise HTTPException(status_code=501, detail="MCP Plugin not available")
+    
+    try:
+        servers = []
+        for name, server in mcp_manager.servers.items():
+            servers.append({
+                "name": name,
+                "description": server.description,
+                "status": server.status,
+                "transport": server.transport,
+                "command": server.command,
+                "args": server.args,
+                "capabilities": server.capabilities
+            })
+        return {"success": True, "data": servers}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/mcp/add")
+async def add_mcp_server(server_request: McpServerAddRequest):
+    """Add a new MCP server configuration."""
+    if not mcp_manager:
+        raise HTTPException(status_code=501, detail="MCP Plugin not available")
+    
+    try:
+        # Create MCPServer object
+        # Validate required fields based on transport type
+        if server_request.transport == "stdio" and not server_request.command:
+            raise HTTPException(status_code=400, detail="Command is required for stdio transport")
+        
+        if server_request.transport in ["http", "sse", "websocket"] and not server_request.url:
+            raise HTTPException(status_code=400, detail="URL is required for remote transports")
+        
+        # More flexible OAuth validation - allow registry servers to be added without client_id initially
+        # The OAuth configuration might be provided by the registry or discovered during connection
+        if server_request.auth_type == "oauth2":
+            # Log the OAuth configuration for debugging
+            print(f"DEBUG: Adding OAuth server '{server_request.name}'")
+            print(f"DEBUG: client_id: {server_request.client_id}")
+            print(f"DEBUG: authorization_server_url: {server_request.authorization_server_url}")
+            print(f"DEBUG: scopes: {server_request.scopes}")
+            # Note: client_id validation removed to allow registry servers with dynamic OAuth discovery
+        
+        server = MCPServer(
+            name=server_request.name,
+            description=server_request.description,
+            command=server_request.command or "",
+            args=server_request.args,
+            env=server_request.env,
+            transport=server_request.transport,
+            url=server_request.url,
+            auth_type=server_request.auth_type,
+            auth_headers=server_request.auth_headers,
+            authorization_server_url=server_request.authorization_server_url,
+            client_id=server_request.client_id,
+            client_secret=server_request.client_secret,
+            scopes=server_request.scopes,
+            redirect_uri=server_request.redirect_uri or f"{server_request.url}/oauth/callback" if server_request.url else None
+        )
+        
+        # Use BASE_URL for redirect_uri if not explicitly provided
+        if not server.redirect_uri and server_request.auth_type == "oauth2":
+            base_url = os.getenv('BASE_URL', 'http://localhost:3000')
+            server.redirect_uri = f"{base_url}/mcp_oauth_cb"
+        
+        mcp_manager.add_server(server_request.name, server)
+        
+        return {
+            "success": True, 
+            "message": f"MCP server '{server_request.name}' added successfully."
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/mcp/remove")
+async def remove_mcp_server(request: McpServerRequest):
+    """Remove an MCP server configuration."""
+    if not mcp_manager:
+        raise HTTPException(status_code=501, detail="MCP Plugin not available")
+    
+    try:
+        # First disconnect if connected
+        if request.server_name in mcp_manager.sessions:
+            await mcp_manager.disconnect_server(request.server_name)
+        
+        # Remove server configuration
+        mcp_manager.remove_server(request.server_name)
+        
+        return {
+            "success": True, 
+            "message": f"MCP server '{request.server_name}' removed successfully."
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/mcp/connect")
+async def connect_mcp_server(request: McpConnectRequest):
+    """Connect to an MCP server."""
+    if not mcp_manager:
+        raise HTTPException(status_code=501, detail="MCP Plugin not available")
+    
+    # Persist secrets if provided
+    if request.secrets:
+        if request.server_name in mcp_manager.servers:
+            server = mcp_manager.servers[request.server_name]
+            if server.secrets is None:
+                server.secrets = {}
+            server.secrets.update(request.secrets)
+            # This will save the updated server config, including secrets
+            mcp_manager.save_config()
+
+    try:
+        success = await mcp_manager.connect_server(request.server_name, secrets=request.secrets)
+        if success:
+            return {
+                "success": True, 
+                "message": f"MCP server '{request.server_name}' connected successfully."
+            }
+        else:
+            print(f"DEBUG: Failed to connect to MCP server '{request.server_name}'")
+            raise HTTPException(
+                status_code=500, 
+                detail=f"Failed to connect to MCP server '{request.server_name}'. Check logs for details."
+            )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/mcp/disconnect")
+async def disconnect_mcp_server(request: McpServerRequest):
+    """Disconnect from an MCP server."""
+    if not mcp_manager:
+        raise HTTPException(status_code=501, detail="MCP Plugin not available")
+    
+    try:
+        success = await mcp_manager.disconnect_server(request.server_name)
+        if success:
+            return {
+                "success": True, 
+                "message": f"MCP server '{request.server_name}' disconnected successfully."
+            }
+        else:
+            raise HTTPException(
+                status_code=500, 
+                detail=f"Failed to disconnect from MCP server '{request.server_name}'."
+            )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

mindroot/coreplugins/admin/mod.py

@@ -0,0 +1,62 @@
+import os
+import subprocess
+from datetime import datetime
+
+async def get_git_version_info(context=None):
+    """Get git commit hash and date of last commit.
+    
+    Returns a dictionary with commit hash and date, or None if not in a git repo.
+    
+    Example:
+    { "get_git_version_info": {} }
+    """
+    try:
+        # Get the current working directory or use a default path
+        repo_path = os.getcwd()
+        if '/files/mindroot' in repo_path or repo_path.endswith('mindroot'):
+            # We're likely in the right place
+            pass
+        else:
+            # Try to find mindroot directory
+            if os.path.exists('/files/mindroot'):
+                repo_path = '/files/mindroot'
+            else:
+                return None
+        
+        # Get commit hash
+        result = subprocess.run(
+            ['git', 'rev-parse', 'HEAD'],
+            cwd=repo_path,
+            capture_output=True,
+            text=True,
+            timeout=10
+        )
+        
+        if result.returncode != 0:
+            return None
+            
+        commit_hash = result.stdout.strip()
+        
+        # Get commit date
+        result = subprocess.run(
+            ['git', 'log', '-1', '--format=%ci'],
+            cwd=repo_path,
+            capture_output=True,
+            text=True,
+            timeout=10
+        )
+        
+        if result.returncode != 0:
+            return None
+            
+        commit_date = result.stdout.strip()
+        
+        return {
+            'commit_hash': commit_hash,
+            'commit_date': commit_date,
+            'retrieved_at': datetime.now().isoformat()
+        }
+        
+    except Exception as e:
+        return None
+

mindroot/coreplugins/admin/oauth_callback_router.py

@@ -0,0 +1,84 @@
+"""OAuth callback router for MCP servers.
+
+This router contains public routes that do not require authentication,
+as external OAuth providers need to be able to redirect to these endpoints.
+"""
+
+from fastapi import APIRouter, Request
+from fastapi.responses import HTMLResponse
+from lib.route_decorators import public_route
+
+# Create router without dependencies - routes will be public
+router = APIRouter()
+
+@router.get("/mcp_oauth_cb")
+@public_route()
+async def mcp_oauth_callback(request: Request):
+    """Handle OAuth callback for MCP servers.
+    
+    This endpoint must be publicly accessible as external OAuth providers
+    will redirect to it without any authentication.
+    """
+    try:
+        # Get query parameters
+        code = request.query_params.get('code')
+        state = request.query_params.get('state')
+        error = request.query_params.get('error')
+        
+        if error:
+            # OAuth error occurred - avoid f-string issues
+            error_html = (
+                "<html><body>"
+                "<h2>OAuth Authorization Failed</h2>"
+                f"<p>Error: {error}</p>"
+                "<p>You can close this window.</p>"
+                "<script>window.close();</script>"
+                "</body></html>"
+            )
+            return HTMLResponse(error_html)
+        
+        if code:
+            # Success - show completion page
+            state_value = state or ""
+            # Build HTML without f-string to avoid escaping issues
+            success_html = (
+                "<html><body>"
+                "<h2>OAuth Authorization Successful</h2>"
+                "<p>Authorization code received. You can close this window.</p>"
+                "<script>"
+                "if (window.opener) {"
+                "window.opener.postMessage({"
+                "type: 'oauth_callback',"
+                f"code: '{code}',"
+                f"state: '{state_value}'"
+                "}, '*');"
+                "}"
+                "setTimeout(() => window.close(), 2000);"
+                "</script>"
+                "</body></html>"
+            )
+            return HTMLResponse(success_html)
+        
+        # No code or error - invalid callback
+        invalid_html = (
+            "<html><body>"
+            "<h2>Invalid OAuth Callback</h2>"
+            "<p>Missing authorization code or error parameter.</p>"
+            "<p>You can close this window.</p>"
+            "<script>window.close();</script>"
+            "</body></html>"
+        )
+        return HTMLResponse(invalid_html)
+        
+    except Exception as e:
+        # Error handling - escape special characters
+        error_message = str(e).replace('"', '&quot;').replace("'", "&#39;")
+        error_html = (
+            "<html><body>"
+            "<h2>OAuth Callback Error</h2>"
+            f"<p>An error occurred processing the OAuth callback: {error_message}</p>"
+            "<p>You can close this window.</p>"
+            "<script>window.close();</script>"
+            "</body></html>"
+        )
+        return HTMLResponse(error_html)

mindroot/coreplugins/admin/persona_handler.py

@@ -27,7 +27,7 @@ def import_persona_from_index(index: str, persona: str):
     print("Successfully imported persona", persona, "from index", index)
 
 
-def handle_persona_import(persona_data: dict, scope: str) -> str:
+def handle_persona_import(persona_data: dict, scope: str, owner: str = None) -> str:
     """Handle importing a persona from embedded data in agent configuration.
     Returns the persona name to be used in agent configuration.
     
@@ -57,13 +57,22 @@ def handle_persona_import(persona_data: dict, scope: str) -> str:
             detail='Persona name required in persona data'
         )
     
-    # Create persona path
-    persona_path = Path('personas') / scope / persona_name / 'persona.json'
+    # For registry installs, use namespaced path
+    if owner and scope == 'registry':
+        persona_path = Path(f'personas/registry/{owner}/{persona_name}/persona.json')
+        return_name = f'registry/{owner}/{persona_name}'
+    else:
+        persona_path = Path('personas') / scope / persona_name / 'persona.json'
+        return_name = persona_name
     
     # Check if persona already exists
     if persona_path.exists():
-        logger.warning(f"Persona '{persona_name}' already exists in {scope} scope - skipping import")
-        return persona_name
+        # For registry personas with owner, we should allow overwrite to support updates
+        if owner and scope == 'registry':
+            logger.info(f"Overwriting existing registry persona '{persona_name}' for owner '{owner}'")
+        else:
+            logger.warning(f"Persona '{persona_name}' already exists in {scope} scope - skipping import")
+            return return_name
     
     try:
         # Create persona directory and save data
@@ -72,7 +81,7 @@ def handle_persona_import(persona_data: dict, scope: str) -> str:
             json.dump(persona_data, f, indent=2)
         
         logger.info(f"Successfully imported persona '{persona_name}' to {scope} scope")
-        return persona_name
+        return return_name
         
     except Exception as e:
         logger.error(f"Failed to import persona '{persona_name}': {str(e)}")

mindroot/coreplugins/admin/persona_router.py

@@ -1,8 +1,10 @@
 from fastapi import APIRouter, HTTPException, UploadFile, File, Form
+from fastapi.responses import Response
 from pathlib import Path
 import json
 import shutil
 import traceback
+from .asset_manager import asset_manager
 
 router = APIRouter()
 
@@ -12,9 +14,13 @@ shared_dir = BASE_DIR / "shared"
 local_dir.mkdir(parents=True, exist_ok=True)
 shared_dir.mkdir(parents=True, exist_ok=True)
 
+# Registry directory for namespaced personas
+registry_dir = BASE_DIR / "registry"
+registry_dir.mkdir(parents=True, exist_ok=True)
+
 @router.get('/personas/{scope}/{name}')
 def read_persona(scope: str, name: str):
-    if scope not in ['local', 'shared']:
+    if scope not in ['local', 'shared', 'registry']:
         raise HTTPException(status_code=400, detail='Invalid scope')
     persona_path = BASE_DIR / scope / name / 'persona.json'
     if not persona_path.exists():
@@ -28,13 +34,163 @@ def read_persona(scope: str, name: str):
 
 @router.get('/personas/{scope}')
 def list_personas(scope: str):
-    if scope not in ['local', 'shared']:
+    if scope not in ['local', 'shared', 'registry']:
         raise HTTPException(status_code=400, detail='Invalid scope')
     scope_dir = BASE_DIR / scope
     personas = [p.name for p in scope_dir.iterdir() if p.is_dir()]
     print(f"Read personas from dir {scope_dir}: {personas}")
     return [{'name': name} for name in personas]
 
+@router.get('/personas/{persona_path:path}')
+def read_persona_by_path(persona_path: str):
+    """Read persona by full path (supports registry/owner/name format)"""
+    try:
+        # Handle registry personas: registry/owner/name
+        if persona_path.startswith('registry/'):
+            full_path = BASE_DIR / persona_path / 'persona.json'
+        else:
+            # Handle simple names: check local first, then shared
+            full_path = BASE_DIR / 'local' / persona_path / 'persona.json'
+            if not full_path.exists():
+                full_path = BASE_DIR / 'shared' / persona_path / 'persona.json'
+        
+        if not full_path.exists():
+            raise HTTPException(status_code=404, detail='Persona not found')
+            
+        with open(full_path, 'r') as f:
+            return json.load(f)
+            
+    except Exception as e:
+        raise HTTPException(status_code=404, detail=f'Persona not found: {str(e)}')
+
+@router.post('/personas/registry')
+def create_registry_persona(persona: str = Form(...), owner: str = Form(...)):
+    """Create a registry persona with owner namespace"""
+    try:
+        persona_data = json.loads(persona)
+        persona_name = persona_data.get('name')
+        
+        if not persona_name:
+            raise HTTPException(status_code=400, detail='Persona name is required')
+        if not owner:
+            raise HTTPException(status_code=400, detail='Owner is required for registry personas')
+        
+        # Create registry persona path: personas/registry/owner/name/
+        persona_path = BASE_DIR / 'registry' / owner / persona_name / 'persona.json'
+        
+        if persona_path.exists():
+            # Update existing persona instead of failing
+            print(f"Updating existing registry persona: {owner}/{persona_name}")
+        
+        persona_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        with open(persona_path, 'w') as f:
+            json.dump(persona_data, f, indent=2)
+            
+        return {'status': 'success', 'path': f'registry/{owner}/{persona_name}'}
+        
+    except Exception as e:
+        print(f"Error creating registry persona: {e}")
+        raise HTTPException(status_code=500, detail=f'Internal server error: {str(e)}')
+
+@router.post('/personas/registry/with-assets')
+def create_registry_persona_with_assets(persona: str = Form(...), owner: str = Form(...), 
+                                       faceref: UploadFile = File(None), avatar: UploadFile = File(None)):
+    """Create a registry persona with deduplicated asset storage"""
+    try:
+        print(f"Received persona data (first 200 chars): {persona[:200]}...")
+        print(f"Received owner: {owner}")
+        print(f"Received faceref: {faceref.filename if faceref else 'None'}")
+        print(f"Received avatar: {avatar.filename if avatar else 'None'}")
+        
+        persona_data = json.loads(persona)
+        persona_name = persona_data.get('name')
+        
+        if not persona_name:
+            raise HTTPException(status_code=400, detail='Persona name is required')
+        if not owner:
+            raise HTTPException(status_code=400, detail='Owner is required for registry personas')
+        
+        # Store assets with deduplication
+        asset_hashes = {}
+        
+        if faceref:
+            content = faceref.file.read()
+            file_hash, was_new = asset_manager.store_content(content, faceref.filename, "faceref")
+            asset_hashes['faceref'] = file_hash
+            
+        if avatar:
+            content = avatar.file.read()
+            file_hash, was_new = asset_manager.store_content(content, avatar.filename, "avatar")
+            asset_hashes['avatar'] = file_hash
+        
+        # Add asset references to persona data
+        persona_data['asset_hashes'] = asset_hashes
+        
+        # For registry personas, update the name to include the owner namespace
+        # This ensures the chat UI can find the images at the correct path
+        if 'name' in persona_data:
+            persona_data['name'] = f"{owner}/{persona_name}"
+        
+        # Create registry persona path first
+        persona_path = BASE_DIR / 'registry' / owner / persona_name / 'persona.json'
+        persona_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        # ALSO copy assets to traditional locations for compatibility
+        if faceref:
+            faceref_path = persona_path.parent / 'faceref.png'
+            faceref_path.parent.mkdir(parents=True, exist_ok=True)
+            with open(faceref_path, 'wb') as f:
+                faceref.file.seek(0)  # Reset file pointer
+                f.write(faceref.file.read())
+                
+        if avatar:
+            avatar_path = persona_path.parent / 'avatar.png'
+            avatar_path.parent.mkdir(parents=True, exist_ok=True)
+            with open(avatar_path, 'wb') as f:
+                avatar.file.seek(0)  # Reset file pointer
+                f.write(avatar.file.read())
+        
+        with open(persona_path, 'w') as f:
+            json.dump(persona_data, f, indent=2)
+            
+        return {
+            'status': 'success', 
+            'path': f'registry/{owner}/{persona_name}',
+            'asset_hashes': asset_hashes
+        }
+        
+    except json.JSONDecodeError as e:
+        print(f"JSON decode error: {e}")
+        print(f"Invalid JSON received: {persona}")
+        raise HTTPException(status_code=400, detail=f'Invalid JSON in persona data: {str(e)}')
+    except Exception as e:
+        print(f"Error creating registry persona with assets: {e}")
+        import traceback
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=f'Internal server error: {str(e)}')
+
+@router.get('/assets/{asset_hash}')
+def serve_asset(asset_hash: str):
+    """Serve a deduplicated asset by hash"""
+    try:
+        asset_path = asset_manager.get_asset_path(asset_hash)
+        if not asset_path:
+            raise HTTPException(status_code=404, detail='Asset not found')
+        
+        metadata = asset_manager.get_asset_metadata(asset_hash)
+        
+        with open(asset_path, 'rb') as f:
+            content = f.read()
+        
+        # Determine content type based on metadata
+        content_type = "image/png" if metadata and metadata.get('type') in ['avatar', 'faceref'] else "application/octet-stream"
+        
+        return Response(content=content, media_type=content_type)
+        
+    except Exception as e:
+        raise HTTPException(status_code=404, detail=f'Asset not found: {str(e)}')
+
 @router.post('/personas/{scope}')
 def create_persona(scope: str, persona: str = Form(...), faceref: UploadFile = File(None), avatar: UploadFile = File(None)):
     try:

mindroot/coreplugins/admin/plugin_manager.py

@@ -12,6 +12,7 @@ from lib.plugins import (
 from lib.plugins.installation import download_github_files
 from lib.streamcmd import stream_command_as_events
 import asyncio
+import httpx
 
 
 router = APIRouter()
@@ -360,3 +361,65 @@ def discover_plugins(directory):
                 continue
 
     return discovered
+
+async def publish_plugin_from_github(repo: str, registry_token: str, registry_url: str):
+    """
+    Fetches plugin_info.json from a GitHub repo and publishes it to the registry.
+    """
+    plugin_info = None
+    # Try to fetch from 'main' and then 'master' branch
+    for branch in ['main', 'master']:
+        url = f"https://raw.githubusercontent.com/{repo}/{branch}/plugin_info.json"
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.get(url)
+                if response.status_code == 200:
+                    plugin_info = response.json()
+                    break
+            except httpx.RequestError as e:
+                # This might happen if the repo is private or other network issues
+                print(f"Error fetching from {url}: {e}")
+                continue
+
+    if not plugin_info:
+        raise Exception(f"Could not find or access plugin_info.json in repo {repo} on 'main' or 'master' branch.")
+
+    # Construct the payload for the registry's /publish endpoint
+    publish_data = {
+        "title": plugin_info.get("name"),
+        "description": plugin_info.get("description", ""),
+        "category": "plugin",
+        "content_type": "mindroot_plugin",
+        "version": plugin_info.get("version", "0.1.0"),
+        "github_url": f"https://github.com/{repo}",
+        "pypi_module": plugin_info.get("pypi_module"),
+        "commands": plugin_info.get("commands", []),
+        "services": plugin_info.get("services", []),
+        "tags": plugin_info.get("tags", ["plugin"]),
+        "dependencies": plugin_info.get("dependencies", []),
+        "data": {
+            "plugin_info": plugin_info,
+            "installation": {
+                "type": "github",
+                "source_path": repo
+            }
+        }
+    }
+
+    # Post the data to the registry
+    publish_url = f"{registry_url}/publish"
+    headers = {
+        "Authorization": f"Bearer {registry_token}",
+        "Content-Type": "application/json"
+    }
+    async with httpx.AsyncClient() as client:
+        response = await client.post(publish_url, json=publish_data, headers=headers)
+
+    if response.status_code >= 400:
+        try:
+            error_detail = response.json().get("detail", response.text)
+        except:
+            error_detail = response.text
+        raise Exception(f"Failed to publish to registry: {response.status_code} - {error_detail}")
+
+    return response.json()

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: