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

mindroot/coreplugins/admin/plugin_router_fixed.py

@@ -0,0 +1,23 @@
+from fastapi import APIRouter
+from lib.route_decorators import requires_role
+
+# Import the separate route modules
+from .plugin_routes import router as plugin_routes
+from .mcp_routes import router as mcp_routes
+from .mcp_catalog_routes import router as mcp_catalog_routes
+from .registry_settings_routes import router as registry_settings_routes
+from .mcp_publish_routes import router as mcp_publish_routes
+from .mcp_registry_routes import router as mcp_registry_routes
+
+# Create main router with admin role requirement
+router = APIRouter(
+    dependencies=[requires_role('admin')]
+)
+
+# Include all the sub-routers
+router.include_router(plugin_routes, tags=["plugins"])
+router.include_router(mcp_routes, tags=["mcp"])
+router.include_router(mcp_catalog_routes, tags=["mcp-catalog"])
+router.include_router(registry_settings_routes, tags=["registry-settings"])
+router.include_router(mcp_publish_routes, tags=["mcp-publish"])
+router.include_router(mcp_registry_routes, tags=["mcp-registry"])

mindroot/coreplugins/admin/plugin_router_new_not_working.py

@@ -0,0 +1,145 @@
+from fastapi import APIRouter, HTTPException, Depends, Header
+from pydantic import BaseModel
+import json
+from typing import Optional, List
+from lib import plugins
+from . import plugin_manager
+from lib.auth.cognito import get_current_user
+from lib.config import get_settings
+
+# Import MCP components
+try:
+    from mindroot.coreplugins.mcp.enhanced_mod import enhanced_mcp_manager
+    from mindroot.coreplugins.mcp.mod import MCPServer
+except ImportError:
+    # Mock objects if MCP plugin is not fully installed, to prevent startup crash
+    enhanced_mcp_manager = None
+    MCPServer = None
+
+router = APIRouter()
+
+class PluginUpdateRequest(BaseModel):
+    plugins: dict
+
+@router.post("/update-plugins")
+def update_plugins(request: PluginUpdateRequest):
+    try:
+        with open('plugins.json', 'r') as file:
+            plugins_data = json.load(file)
+
+        for plugin in plugins_data:
+            if plugin['name'] in request.plugins:
+                plugin['enabled'] = request.plugins[plugin['name']]
+
+        with open('plugins.json', 'w') as file:
+            json.dump(plugins_data, file, indent=2)
+
+        plugins.load('data/plugin_manifest.json')
+
+        return {"message": "Plugins updated successfully"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/get-plugins")
+async def get_plugins():
+    try:
+        return plugins.load_plugin_manifest()
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+class GithubPublishRequest(BaseModel):
+    repo: str
+    registry_url: str
+
+@router.post("/plugins/publish_from_github")
+async def publish_from_github(request: GithubPublishRequest, authorization: Optional[str] = Header(None), user: dict = Depends(get_current_user)):
+    if not user:
+        raise HTTPException(status_code=401, detail="Not authorized for Mindroot Admin")
+
+    registry_token = None
+    if authorization and authorization.startswith("Bearer "):
+        registry_token = authorization.split(" ")[1]
+
+    if not registry_token:
+        raise HTTPException(status_code=401, detail="Registry auth token not provided")
+
+    try:
+        result = await plugin_manager.publish_plugin_from_github(request.repo, registry_token, request.registry_url)
+        return {"message": f"Plugin '{result.get('title')}' published successfully!", "data": result}
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=str(e))
+
+class GithubPublishRequest(BaseModel):
+    repo: str
+
+@router.post("/plugins/publish_from_github")
+async def publish_from_github(request: GithubPublishRequest, user: dict = Depends(get_current_user)):
+    if not user:
+        raise HTTPException(status_code=401, detail="Not authorized")
+    try:
+        result = await plugin_manager.publish_plugin_from_github(request.repo, user)
+        return {"message": "Plugin published successfully", "data": result}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+# --- MCP Integration Routes ---
+
+class McpServerRequest(BaseModel):
+    server_name: str
+
+@router.get("/mcp/list")
+async def list_mcp_servers(user: dict = Depends(get_current_user)):
+    if not enhanced_mcp_manager:
+        raise HTTPException(status_code=501, detail="MCP Plugin not available")
+    servers = [s.dict() for s in enhanced_mcp_manager.servers.values()]
+    return {"success": True, "data": servers}
+
+@router.post("/mcp/add")
+async def add_mcp_server(server_config: MCPServer, user: dict = Depends(get_current_user)):
+    if not enhanced_mcp_manager:
+        raise HTTPException(status_code=501, detail="MCP Plugin not available")
+    try:
+        # The server_config is a full MCPServer object from the registry
+        enhanced_mcp_manager.add_server(server_config.name, server_config)
+        return {"success": True, "message": f"Server '{server_config.name}' added."}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/mcp/remove")
+async def remove_mcp_server(request: McpServerRequest, user: dict = Depends(get_current_user)):
+    if not enhanced_mcp_manager:
+        raise HTTPException(status_code=501, detail="MCP Plugin not available")
+    try:
+        await enhanced_mcp_manager.remove_server(request.server_name)
+        return {"success": True, "message": f"Server '{request.server_name}' removed."}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/mcp/connect")
+async def connect_mcp_server(request: McpServerRequest, user: dict = Depends(get_current_user)):
+    if not enhanced_mcp_manager:
+        raise HTTPException(status_code=501, detail="MCP Plugin not available")
+    try:
+        success = await enhanced_mcp_manager.connect_server(request.server_name)
+        if success:
+            return {"success": True, "message": f"Server '{request.server_name}' connected."}
+        else:
+            raise HTTPException(status_code=500, detail=f"Failed to connect to server '{request.server_name}'. Check logs.")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/mcp/disconnect")
+async def disconnect_mcp_server(request: McpServerRequest, user: dict = Depends(get_current_user)):
+    if not enhanced_mcp_manager:
+        raise HTTPException(status_code=501, detail="MCP Plugin not available")
+    try:
+        success = await enhanced_mcp_manager.disconnect_server(request.server_name)
+        if success:
+            return {"success": True, "message": f"Server '{request.server_name}' disconnected."}
+        else:
+            raise HTTPException(status_code=500, detail=f"Failed to disconnect from server '{request.server_name}'.")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+

mindroot/coreplugins/admin/plugin_routes.py

@@ -0,0 +1,114 @@
+from fastapi import APIRouter, HTTPException, Header
+from pydantic import BaseModel
+import json
+import os
+from typing import Optional
+from lib import plugins
+from . import plugin_manager
+from lib.route_decorators import requires_role
+
+# Create router with admin role requirement
+router = APIRouter(
+    dependencies=[requires_role('admin')]
+)
+
+class PluginUpdateRequest(BaseModel):
+    plugins: dict
+
+class GithubPublishRequest(BaseModel):
+    repo: str
+    registry_url: Optional[str] = None
+
+# --- Plugin Management Routes ---
+
+@router.post("/update-plugins")
+def update_plugins(request: PluginUpdateRequest):
+    """Update plugin enabled/disabled status."""
+    try:
+        with open('plugins.json', 'r') as file:
+            plugins_data = json.load(file)
+
+        for plugin in plugins_data:
+            if plugin['name'] in request.plugins:
+                plugin['enabled'] = request.plugins[plugin['name']]
+
+        with open('plugins.json', 'w') as file:
+            json.dump(plugins_data, file, indent=2)
+
+        plugins.load('data/plugin_manifest.json')
+
+        return {"message": "Plugins updated successfully"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/get-plugins")
+async def get_plugins():
+    """Get list of all plugins."""
+    try:
+        return plugins.load_plugin_manifest()
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/plugins/publish_from_github")
+async def publish_plugin_from_github(
+    request: GithubPublishRequest, 
+    authorization: Optional[str] = Header(None)
+):
+    """Publish a plugin from GitHub repository to the registry.
+    
+    This endpoint allows publishing a plugin by simply providing the GitHub
+    repository in the format 'username/repo'. It will fetch the plugin_info.json
+    from the repository and publish it to the configured registry.
+    
+    The registry token can be provided via:
+    1. Authorization header: "Bearer <token>"
+    2. REGISTRY_TOKEN environment variable
+    3. registry_token in data/registry_settings.json
+    """
+    try:
+        # Get registry token from multiple sources
+        registry_token = None
+        
+        # 1. Try Authorization header
+        if authorization and authorization.startswith("Bearer "):
+            registry_token = authorization.split(" ")[1]
+        
+        # 2. Try environment variable
+        if not registry_token:
+            registry_token = os.getenv('REGISTRY_TOKEN')
+        
+        # 3. Try settings file
+        if not registry_token:
+            try:
+                settings_file = 'data/registry_settings.json'
+                if os.path.exists(settings_file):
+                    with open(settings_file, 'r') as f:
+                        settings = json.load(f)
+                        registry_token = settings.get('registry_token')
+            except Exception as e:
+                print(f"Error reading registry settings: {e}")
+        
+        if not registry_token:
+            raise HTTPException(
+                status_code=401, 
+                detail="Registry authentication token not provided. Please provide via Authorization header, REGISTRY_TOKEN environment variable, or registry_settings.json file."
+            )
+        
+        # Use the existing plugin_manager functionality
+        registry_url = request.registry_url or "https://registry.mindroot.io"
+        
+        result = await plugin_manager.publish_plugin_from_github(
+            request.repo, 
+            registry_token, 
+            registry_url
+        )
+        
+        return {
+            "success": True,
+            "message": f"Plugin '{result.get('title', request.repo)}' published successfully!", 
+            "data": result
+        }
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=str(e))

mindroot/coreplugins/admin/registry_settings_routes.py

@@ -0,0 +1,140 @@
+from fastapi import APIRouter, HTTPException
+import json
+import os
+from lib.route_decorators import requires_role
+
+# Create router with admin role requirement
+router = APIRouter(
+    dependencies=[requires_role('admin')]
+)
+
+# --- Registry Settings Routes ---
+
+@router.get("/registry/settings")
+async def get_registry_settings():
+    """Get registry settings including token status."""
+    try:
+        settings_file = 'data/registry_settings.json'
+        settings = {}
+        
+        if os.path.exists(settings_file):
+            with open(settings_file, 'r') as f:
+                settings = json.load(f)
+        
+        # Don't return the actual token, just indicate if it's set
+        return {
+            "success": True,
+            "data": {
+                "registry_url": settings.get("registry_url", "https://registry.mindroot.io"),
+                "has_token": bool(settings.get("registry_token")),
+                "token_source": "file" if settings.get("registry_token") else "env" if os.getenv('REGISTRY_TOKEN') else "none"
+            }
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/registry/settings")
+async def update_registry_settings(settings_data: dict):
+    """Update registry settings."""
+    try:
+        settings_file = 'data/registry_settings.json'
+        
+        # Ensure data directory exists
+        os.makedirs('data', exist_ok=True)
+        
+        # Load existing settings
+        settings = {}
+        if os.path.exists(settings_file):
+            with open(settings_file, 'r') as f:
+                settings = json.load(f)
+        
+        # Update with new data
+        settings.update(settings_data)
+        
+        # Save updated settings
+        with open(settings_file, 'w') as f:
+            json.dump(settings, f, indent=2)
+        
+        return {
+            "success": True,
+            "message": "Registry settings updated successfully.",
+            "data": {
+                "registry_url": settings.get("registry_url", "https://registry.mindroot.io"),
+                "has_token": bool(settings.get("registry_token")),
+                "token_source": "file" if settings.get("registry_token") else "env" if os.getenv('REGISTRY_TOKEN') else "none"
+            }
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.delete("/registry/settings/token")
+async def clear_registry_token():
+    """Clear the stored registry token."""
+    try:
+        settings_file = 'data/registry_settings.json'
+        
+        if os.path.exists(settings_file):
+            with open(settings_file, 'r') as f:
+                settings = json.load(f)
+            
+            # Remove token if it exists
+            if 'registry_token' in settings:
+                del settings['registry_token']
+                
+                with open(settings_file, 'w') as f:
+                    json.dump(settings, f, indent=2)
+        
+        return {
+            "success": True,
+            "message": "Registry token cleared successfully."
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/registry/test-connection")
+async def test_registry_connection():
+    """Test connection to the registry."""
+    try:
+        import httpx
+        
+        settings_file = 'data/registry_settings.json'
+        registry_url = "https://registry.mindroot.io"
+        
+        if os.path.exists(settings_file):
+            with open(settings_file, 'r') as f:
+                settings = json.load(f)
+                registry_url = settings.get("registry_url", registry_url)
+        
+        # Test connection to registry
+        async with httpx.AsyncClient(timeout=10.0) as client:
+            response = await client.get(f"{registry_url}/stats")
+            
+            if response.status_code == 200:
+                stats = response.json()
+                return {
+                    "success": True,
+                    "message": "Successfully connected to registry.",
+                    "data": {
+                        "registry_url": registry_url,
+                        "stats": stats
+                    }
+                }
+            else:
+                return {
+                    "success": False,
+                    "message": f"Registry returned status code {response.status_code}",
+                    "data": {
+                        "registry_url": registry_url,
+                        "status_code": response.status_code
+                    }
+                }
+                
+    except Exception as e:
+        return {
+            "success": False,
+            "message": f"Failed to connect to registry: {str(e)}",
+            "data": {
+                "registry_url": registry_url,
+                "error": str(e)
+            }
+        }

mindroot/coreplugins/admin/router.py

@@ -1,47 +1,148 @@
 import nanoid
+import os
+import json
+from pathlib import Path
 from fastapi import APIRouter, HTTPException, Request
-from fastapi.responses import HTMLResponse, RedirectResponse
+from fastapi.responses import HTMLResponse, RedirectResponse, JSONResponse, Response
 from lib.plugins import list_enabled
 from lib.templates import render
 from .plugin_manager import router as plugin_manager_router
 from lib.route_decorators import requires_role
+from .mod import get_git_version_info
 
-# Create admin router with role requirement for all routes under it
-router = APIRouter(
-    dependencies=[requires_role('admin')]
-)
+# Create separate routers for public and admin routes
+public_router = APIRouter()  # No dependencies - for OAuth callbacks etc.
+admin_router = APIRouter(dependencies=[requires_role('admin')])  # Admin only
 
-router.include_router(plugin_manager_router, prefix="/plugin-manager", tags=["plugin-manager"])
+# === PUBLIC ROUTES (no authentication required) ===
+# Import and include the OAuth callback router in public router
+from .oauth_callback_router import router as oauth_callback_router
+public_router.include_router(oauth_callback_router)
 
-@router.get("/admin", response_class=HTMLResponse)
+# === ADMIN ROUTES (authentication required) ===
+admin_router.include_router(plugin_manager_router, prefix="/plugin-manager", tags=["plugin-manager"])
+
+@admin_router.get("/admin", response_class=HTMLResponse)
 async def get_admin_html():
     log_id = nanoid.generate()
     plugins = list_enabled()
     html = await render('admin', {"log_id": log_id})
     return html
 
+@admin_router.post("/admin/get-version-info")
+async def get_version_info():
+    """Get version information, trying git first, then falling back to cached file."""
+    try:
+        # Get the path to this file to determine where to store version.txt
+        current_file = Path(__file__)
+        version_file = current_file.parent / "version.txt"
+        
+        # Try to get fresh git info using the command
+        try:
+            if get_git_version_info:
+                git_info = await get_git_version_info()
+                if git_info:
+                    # Write to version.txt
+                    with open(version_file, 'w') as f:
+                        json.dump(git_info, f, indent=2)
+                    return JSONResponse(git_info)
+        except Exception as e:
+            print(f"Failed to get git info: {e}")
+        
+        # Fall back to reading from version.txt
+        if version_file.exists():
+            with open(version_file, 'r') as f:
+                cached_info = json.load(f)
+                # Add note that this is cached
+                cached_info['note'] = 'Cached version (git not available)'
+                return JSONResponse(cached_info)
+        
+        # No version info available
+        return JSONResponse({
+            'commit_hash': 'Unknown',
+            'commit_date': 'Unknown',
+            'retrieved_at': 'Unknown',
+            'note': 'Version information not available'
+        })
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error getting version info: {str(e)}")
 
 from lib.logging.log_router import router as log_router
-router.include_router(log_router)
+admin_router.include_router(log_router)
 
 from .command_router import router as command_router
-router.include_router(command_router)
+admin_router.include_router(command_router)
 
 from .settings_router import router as settings_router
-router.include_router(settings_router)
+admin_router.include_router(settings_router)
+
+# Use the fixed plugin router instead of the old one
+from .plugin_router_fixed import router as plugin_router_fixed
+admin_router.include_router(plugin_router_fixed, prefix="/admin", tags=["plugins", "mcp"])
 
+# Keep the old plugin router for backward compatibility if needed
 from .plugin_router import router as plugin_router
-router.include_router(plugin_router)
+admin_router.include_router(plugin_router, prefix="/admin/legacy", tags=["legacy-plugins"])
 
 from .persona_router import router as persona_router
-router.include_router(persona_router)
+admin_router.include_router(persona_router)
 
 from .agent_router import router as agent_router
-router.include_router(agent_router)
+admin_router.include_router(agent_router)
 
 from .server_router import router as server_router
-router.include_router(server_router, prefix="/admin/server", tags=["server"])
+admin_router.include_router(server_router, prefix="/admin/server", tags=["server"])
 
 # Import and include the env_manager router
 from coreplugins.env_manager.router import router as env_manager_router
-router.include_router(env_manager_router)
+admin_router.include_router(env_manager_router)
+
+@admin_router.post("/admin/update-mindroot")
+async def update_mindroot():
+    """Update MindRoot using pip install --upgrade mindroot"""
+    import subprocess
+    import sys
+    
+    try:
+        # Run pip install --upgrade mindroot in the current environment
+        result = subprocess.run(
+            [sys.executable, "-m", "pip", "install", "--upgrade", "mindroot"],
+            capture_output=True,
+            text=True,
+            timeout=300  # 5 minute timeout
+        )
+        
+        if result.returncode == 0:
+            return JSONResponse({
+                "success": True,
+                "message": "MindRoot updated successfully",
+                "output": result.stdout,
+                "note": "Restart the application to use the updated version"
+            })
+        else:
+            return JSONResponse({
+                "success": False,
+                "message": "Failed to update MindRoot",
+                "error": result.stderr,
+                "output": result.stdout
+            })
+            
+    except subprocess.TimeoutExpired:
+        return JSONResponse({
+            "success": False,
+            "message": "Update timed out after 5 minutes",
+            "error": "Process timed out"
+        })
+    except Exception as e:
+        return JSONResponse({
+            "success": False,
+            "message": "Error during update",
+            "error": str(e)
+        })
+
+# === MAIN ROUTER COMBINING PUBLIC AND ADMIN ===
+# Create main router that combines both public and admin routes
+router = APIRouter()
+router.include_router(public_router)  # Public routes first (no auth)
+router.include_router(admin_router)   # Admin routes (with auth)

mindroot/coreplugins/admin/service_models.py

@@ -71,7 +71,7 @@ async def get_service_models_from_providers(timeout: float = 500.0, context=None
     print(f"Querying {len(providers)} providers for service models...")
     provider_tasks = [query_provider(provider) for provider in providers]
     provider_results = await asyncio.gather(*provider_tasks)
-    print(provider_results)
+    #print(provider_results)
     # Organize results by service, then by provider
     service_models: Dict[str, Dict[str, List[str]]] = {}
     

mindroot/coreplugins/admin/settings_router.py

@@ -110,6 +110,7 @@ async def get_providers():
 @router.get('/commands', response_model=Dict)
 async def get_commands():
     print("retrieving commands")
+    print(f"settings_router: command_manager instance ID: {id(command_manager)}")
     #funcs = command_manager.get_functions()
     funcs = command_manager.get_detailed_functions()
     print("funcs is")