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

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()
@@ -52,15 +53,22 @@ import sys, os, shlex
 async def stream_install_plugin(request: StreamInstallRequest):
     """Stream the installation process of a plugin using SSE (POST method)."""
     # Prepare the command based on the source
-    if request.source == 'github_direct':
-        cmd = [sys.executable, '-m', 'pip', 'install', '-e', request.source_path, '-v', '--no-cache-dir']
+    print("Stream Install Request:", request)
+    if request.source == 'github_direct' or request.source == 'github':
+        if request.source_path.startswith('https://'):
+            # For direct GitHub URLs, we can use the pip install directly
+            cmd = [sys.executable, '-m', 'pip', 'install', request.source_path, '-v', '--no-cache-dir']
+        else:
+            cmd = [sys.executable, '-m', 'pip', 'install', '-e', request.source_path, '-v', '--no-cache-dir']
     elif request.source == 'local':
         cmd = [sys.executable, '-m', 'pip', 'install', '-e', request.source_path, '-v', '--no-cache-dir']
     elif request.source == 'pypi':
         cmd = [sys.executable, '-m', 'pip', 'install', request.plugin, '-v', '--no-cache-dir']
     else:
+        print("Invalid source")
         return {"success": False, "message": "Invalid source"}
 
+    print("Command to execute:", cmd)
     # For GitHub installations, use the plugin_install function which handles the download and extraction
     if request.source == 'github':
         try:
@@ -69,10 +77,14 @@ async def stream_install_plugin(request: StreamInstallRequest):
             repo_path = parts[0]
             tag = parts[1] if len(parts) > 1 else None
             
+            print(1)
+
             async def stream_github_install():
+                print("dling")
                 yield {"event": "message", "data": f"Downloading GitHub repository {repo_path}..."}
                 
                 try:
+                    print("dling 2")
                     plugin_dir, _, plugin_info = download_github_files(repo_path, tag)
                     
                     cmd = [sys.executable, '-m', 'pip', 'install', '-e', plugin_dir, '-v', '--no-cache-dir']
@@ -85,18 +97,24 @@ async def stream_install_plugin(request: StreamInstallRequest):
                         metadata=plugin_info
                     )
                 except Exception as e:
+                    print(e)
                     yield {"event": "error", "data": f"Error installing from GitHub: {str(e)}"}
             
             return EventSourceResponse(stream_github_install())
         except Exception as e:
+            print(3)
+            print(e)
             return {"success": False, "message": f"Error setting up GitHub installation: {str(e)}"}
     
     # For other sources, use our streamcmd module to stream the command output
+    print("stream cmd as events")
     return EventSourceResponse(stream_command_as_events(cmd))
+
 @router.get("/stream-install-plugin", response_class=EventSourceResponse)
 async def stream_install_plugin_get(request: Request):
     """Stream the installation process of a plugin using SSE (GET method)."""
     # Extract parameters from query string
+    print("Stream Install GET Request:", request.query_params)
     plugin = request.query_params.get("plugin", "")
     source = request.query_params.get("source", "")
     source_path = request.query_params.get("source_path", "")
@@ -114,22 +132,36 @@ async def stream_install_plugin_get(request: Request):
     else:  
         return {"success": False, "message": "Invalid source"}
 
+    print("Command to execute:", cmd)
+    tag = None
     # For GitHub installations, use the plugin_install function which handles the download and extraction
     if source == 'github':
         try:
             # Use the streaming approach for GitHub installations
+            print("source_path:", source_path)
             parts = source_path.split(':')
             repo_path = parts[0]
             tag = parts[1] if len(parts) > 1 else None
-            
+            print("repo_path:", repo_path, "tag:", tag)
             # First yield a message about downloading
+            #
             async def stream_github_install():
                 yield {"event": "message", "data": f"Downloading GitHub repository {repo_path}..."}
-                
+                repo_path_ = repo_path
+                tag_ = tag
                 # Download and extract the GitHub repository
                 try:
-                    plugin_dir, _, plugin_info = download_github_files(repo_path, tag)
-                    
+                    if source_path.startswith('https://'):
+                        print("Processing direct GitHub URL")
+                        repo_path_ = source_path
+                        tag_ = None
+                        parts = repo_path_.split('/')
+                        if len(parts) >= 5:
+                            repo_path_ = f"{parts[3]}/{parts[4]}"
+
+                    print("repo_path_:", repo_path_)
+                    plugin_dir, _, plugin_info = download_github_files(repo_path_, tag_)
+                    print('ok')
                     # Now stream the installation from the local directory
                     cmd = [sys.executable, '-m', 'pip', 'install', '-e', plugin_dir, '-v', '--no-cache-dir']
                     async for event in stream_command_as_events(cmd):
@@ -138,15 +170,17 @@ async def stream_install_plugin_get(request: Request):
                     # Update the plugin manifest
                     update_plugin_manifest(
                         plugin_info['name'], 'github', os.path.abspath(plugin_dir),
-                        remote_source=repo_path, version=plugin_info.get('version', '0.0.1'),
+                        remote_source=repo_path_, version=plugin_info.get('version', '0.0.1'),
                         metadata=plugin_info
                     )
                 except Exception as e:
-                    yield {"event": "error", "data": f"Error installing from GitHub: {str(e)}"}
+                    trace = traceback.format_exc()
+                    yield {"event": "error", "data": f"Error installing from GitHub: {str(e)} \n\n{trace}"}
             
             return EventSourceResponse(stream_github_install())
         except Exception as e:
-            return {"success": False, "message": f"Error installing from GitHub: {str(e)}"}
+            trace = traceback.format_exc()
+            return {"success": False, "message": f"Error installing from GitHub: {str(e)}\n\n{trace}"}
     
     # Use our new streamcmd module
     return EventSourceResponse(stream_command_as_events(cmd))
@@ -360,3 +394,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_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)
+            }
+        }