mindroot 0.1.0__py3-none-any.whl

mindroot/__init__.py

@@ -0,0 +1 @@
+# This file is intentionally left empty to mark the directory as a Python package.

mindroot/coreplugins/admin/__init__.py

@@ -0,0 +1 @@
+ # This file is required to make Python treat the directory as a package.

mindroot/coreplugins/admin/agent_importer.py

@@ -0,0 +1,173 @@
+from pathlib import Path
+import json
+import shutil
+import logging
+from typing import Dict, List
+import os
+import tempfile
+import requests
+import zipfile
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# These should be moved to a config file or environment variables
+AGENT_BASE_DIR = Path('data/agents')
+PERSONA_BASE_DIR = Path('personas')
+
+CONFIRM_OVERWRITE_AGENT = os.environ.get('CONFIRM_OVERWRITE_AGENT', 'false')
+if CONFIRM_OVERWRITE_AGENT.lower() in ['true', '1']:
+    CONFIRM_OVERWRITE_AGENT = True
+else:
+    CONFIRM_OVERWRITE_AGENT = False
+
+def download_github_files(repo_path: str, tag: str = None) -> tuple[str, str]:
+    """Download GitHub repo files to temp directory"""
+    # Format the download URL
+    if tag:
+        download_url = f"https://github.com/{repo_path}/archive/refs/tags/{tag}.zip"
+    else:
+        download_url = f"https://github.com/{repo_path}/archive/refs/heads/main.zip"
+    
+    # Create temp directory
+    temp_dir = tempfile.mkdtemp()
+    zip_path = os.path.join(temp_dir, 'repo.zip')
+    
+    try:
+        # Download the zip file
+        response = requests.get(download_url)
+        response.raise_for_status()
+        
+        with open(zip_path, 'wb') as f:
+            f.write(response.content)
+        
+        # Extract zip
+        with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+            zip_ref.extractall(temp_dir)
+        
+        return temp_dir, os.path.dirname(zip_path)
+            
+    except Exception as e:
+        shutil.rmtree(temp_dir)
+        raise e
+
+def scan_for_agents(directory: Path) -> Dict[str, Dict]:
+    discovered_agents = {}
+    for agent_file in directory.rglob('agent.json'):
+        try:
+            with agent_file.open('r') as f:
+                agent_data = json.load(f)
+            agent_name = agent_data.get('name')
+            if agent_name:
+                discovered_agents[agent_name] = {
+                    'path': agent_file.parent,
+                    'data': agent_data
+                }
+        except json.JSONDecodeError:
+            logger.error(f"Failed to parse agent file: {agent_file}")
+        except PermissionError:
+            logger.error(f"Permission denied when reading: {agent_file}")
+    return discovered_agents
+
+def validate_agent_structure(agent_data: Dict) -> bool:
+    required_fields = ['name', 'persona', 'commands']
+    return all(field in agent_data for field in required_fields)
+
+def import_agent(agent_name: str, agent_info: Dict, scope: str) -> None:
+    target_dir = Path(AGENT_BASE_DIR) / scope / agent_name
+    if CONFIRM_OVERWRITE_AGENT and target_dir.exists():
+        logger.warning(f"Agent {agent_name} already exists in {scope} scope, skipping")
+        return
+    
+    if not validate_agent_structure(agent_info['data']):
+        logger.error(f"Agent {agent_name} has invalid structure, skipping")
+        return
+
+    try:
+        shutil.copytree(agent_info['path'], target_dir, dirs_exist_ok=True)
+        logger.info(f"Imported agent {agent_name} to {target_dir}")
+
+        persona_name = agent_info['data'].get('persona')
+        if persona_name:
+            persona_dir = os.path.join(agent_info['path'].parent.parent, "personas")
+            import_persona(persona_name, persona_dir, scope)
+    except PermissionError:
+        logger.error(f"Permission denied when copying agent {agent_name}")
+    except shutil.Error as e:
+        logger.error(f"Error copying agent {agent_name}: {e}")
+
+def import_persona(persona_name: str, source_dir: Path, scope: str) -> None:
+    persona_source = Path(source_dir) / persona_name
+    if not persona_source.exists():
+        logger.warning(f"Referenced persona {persona_name} not found in {source_dir}")
+        return
+    
+    persona_target = PERSONA_BASE_DIR / scope / persona_name
+    if CONFIRM_OVERWRITE_AGENT and persona_target.exists():
+        logger.warning(f"Persona {persona_name} already exists, skipping import")
+        return
+    
+    try:
+        shutil.copytree(persona_source, persona_target, dirs_exist_ok=True)
+        logger.info(f"Imported persona {persona_name} to {persona_target}")
+    except PermissionError:
+        logger.error(f"Permission denied when copying persona {persona_name}")
+    except shutil.Error as e:
+        logger.error(f"Error copying persona {persona_name}: {e}")
+
+def scan_and_import_agents(directory: Path, scope: str) -> Dict[str, List[str]]:
+    if not directory.is_dir():
+        raise ValueError(f"Invalid directory path: {directory}")
+    
+    if scope not in ['local', 'shared']:
+        raise ValueError(f"Invalid scope: {scope}")
+    
+    discovered_agents = scan_for_agents(directory)
+    
+    imported_agents = []
+    for agent_name, agent_info in discovered_agents.items():
+        try:
+            import_agent(agent_name, agent_info, scope)
+            imported_agents.append(agent_name)
+        except Exception as e:
+            logger.error(f"Failed to import agent {agent_name}: {e}")
+    
+    return {
+        'imported_agents': imported_agents,
+        'total_imported': len(imported_agents),
+        'total_discovered': len(discovered_agents)
+    }
+
+def import_github_agent(repo_path: str, scope: str, tag: str = None) -> Dict[str, any]:
+    """Import an agent from a GitHub repository"""
+    try:
+        # Download and extract GitHub repository
+        temp_dir, extract_path = download_github_files(repo_path, tag)
+        
+        try:
+            # Scan the downloaded directory for agents
+            discovered = scan_for_agents(Path(temp_dir))
+            if not discovered:
+                raise ValueError("No valid agents found in repository")
+            
+            # Import each discovered agent
+            result = scan_and_import_agents(Path(temp_dir), scope)
+            
+            return {
+                'success': True,
+                'message': f"Successfully imported {result['total_imported']} agents from GitHub",
+                'imported_agents': result['imported_agents']
+            }
+            
+        finally:
+            # Clean up temp directory
+            shutil.rmtree(temp_dir)
+            
+    except Exception as e:
+        logger.error(f"Failed to import agent from GitHub: {str(e)}")
+        return {
+            'success': False,
+            'message': f"Failed to import agent: {str(e)}",
+            'imported_agents': []
+        }

mindroot/coreplugins/admin/agent_router.py

@@ -0,0 +1,163 @@
+from fastapi import APIRouter, HTTPException, UploadFile, File, Form
+from pydantic import BaseModel
+from pathlib import Path
+import json
+from .agent_importer import scan_and_import_agents, import_github_agent
+from .persona_handler import handle_persona_import
+
+router = APIRouter()
+
+BASE_DIR = Path('data/agents')
+local_dir = BASE_DIR / "local"
+shared_dir = BASE_DIR / "shared"
+local_dir.mkdir(parents=True, exist_ok=True)
+shared_dir.mkdir(parents=True, exist_ok=True)
+
+class GitHubImportRequest(BaseModel):
+    repo_path: str  # Format: "owner/repo"
+    scope: str
+    tag: str = None
+
+async def load_persona_data(persona_name: str) -> dict:
+    """Load persona data from local or shared directory"""
+    persona_path = Path('personas/local') / persona_name / 'persona.json'
+    if not persona_path.exists():
+        persona_path = Path('personas/shared') / persona_name / 'persona.json'
+        
+    if not persona_path.exists():
+        return {}
+        
+    with open(persona_path, 'r') as f:
+        return json.load(f)
+
+async def load_agent_data(agent_name: str) -> dict:
+    """Load agent data from local or shared directory"""
+    agent_path = BASE_DIR / 'local' / agent_name / 'agent.json'
+    if not agent_path.exists():
+        agent_path = BASE_DIR / 'shared' / agent_name / 'agent.json'
+        if not agent_path.exists():
+            raise FileNotFoundError(f'Agent {agent_name} not found')
+    
+    with open(agent_path, 'r') as f:
+        agent_data = json.load(f)
+        
+    # Get the persona data if specified
+    if 'persona' in agent_data:
+        persona_data = await load_persona_data(agent_data['persona'])
+        agent_data['persona'] = persona_data
+        
+    return agent_data
+
+@router.get('/agents/full/{scope}/{name}')
+async def get_full_agent_data(scope: str, name: str):
+    """Get complete agent data including persona"""
+    if scope not in ['local', 'shared']:
+        raise HTTPException(status_code=400, detail='Invalid scope')
+    
+    try:
+        agent_data = await load_agent_data(name)
+        return agent_data
+    except FileNotFoundError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get('/agents/{scope}/{name}')
+def read_agent(scope: str, name: str):
+    if scope not in ['local', 'shared']:
+        raise HTTPException(status_code=400, detail='Invalid scope')
+    agent_path = BASE_DIR / scope / name / 'agent.json'
+    if not agent_path.exists():
+        raise HTTPException(status_code=404, detail='Agent not found')
+    with open(agent_path, 'r') as f:
+        agent = json.load(f)
+    return agent
+
+@router.get('/agents/{scope}')
+def list_agents(scope: str):
+    if scope not in ['local', 'shared']:
+        raise HTTPException(status_code=400, detail='Invalid scope')
+    scope_dir = BASE_DIR / scope
+    agents = [p.name for p in scope_dir.iterdir() if p.is_dir()]
+    return [{'name': name} for name in agents]
+
+@router.post('/agents/{scope}')
+def create_agent(scope: str, agent: str = Form(...)):
+    try:
+        agent_data = json.loads(agent)
+        if scope not in ['local', 'shared']:
+            raise HTTPException(status_code=400, detail='Invalid scope')
+        
+        agent_name = agent_data.get('name')
+        if not agent_name:
+            raise HTTPException(status_code=400, detail='Agent name is required')
+            
+        # Handle persona if present
+        if 'persona' in agent_data:
+            # This will either return the persona name or handle the import
+            # and return the name
+            persona_name = handle_persona_import(agent_data['persona'], scope)
+            agent_data['persona'] = persona_name
+            
+        agent_path = BASE_DIR / scope / agent_name / 'agent.json'
+        if agent_path.exists():
+            raise HTTPException(status_code=400, detail='Agent already exists')
+            
+        agent_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(agent_path, 'w') as f:
+            json.dump(agent_data, f, indent=2)
+            
+        return {'status': 'success'}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail='Internal server error ' + str(e))
+
+@router.put('/agents/{scope}/{name}')
+def update_agent(scope: str, name: str, agent: str = Form(...)):
+    try:
+        agent = json.loads(agent)
+        if scope not in ['local', 'shared']:
+            raise HTTPException(status_code=400, detail='Invalid scope')
+        agent_path = BASE_DIR / scope / name / 'agent.json'
+        if not agent_path.exists():
+            raise HTTPException(status_code=404, detail='Agent not found')
+        with open(agent_path, 'w') as f:
+            json.dump(agent, f, indent=2)
+        return {'status': 'success'}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail='Internal server error ' + str(e))
+
+class ScanDirectoryRequest(BaseModel):
+    directory: str
+    scope: str
+
+@router.post('/scan-and-import-agents')
+def scan_and_import_agents_endpoint(request: ScanDirectoryRequest):
+    try:
+        result = scan_and_import_agents(Path(request.directory), request.scope)
+        return {
+            'success': True,
+            'message': f"Imported {result['total_imported']} out of {result['total_discovered']} discovered agents",
+            'imported_agents': result['imported_agents']
+        }
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error during import: {str(e)}")
+
+@router.post('/import-github-agent')
+def import_github_agent_endpoint(request: GitHubImportRequest):
+    try:
+        if request.scope not in ['local', 'shared']:
+            raise HTTPException(status_code=400, detail='Invalid scope')
+
+        result = import_github_agent(request.repo_path, request.scope, request.tag)
+        
+        if not result['success']:
+            raise HTTPException(status_code=400, detail=result['message'])
+            
+        return result
+        
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error during GitHub import: {str(e)}")

mindroot/coreplugins/admin/persona_handler.py

@@ -0,0 +1,62 @@
+from pathlib import Path
+import json
+import logging
+from fastapi import HTTPException
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def handle_persona_import(persona_data: dict, scope: str) -> str:
+    """Handle importing a persona from embedded data in agent configuration.
+    Returns the persona name to be used in agent configuration.
+    
+    Args:
+        persona_data: Dictionary containing persona data or string with persona name
+        scope: 'local' or 'shared'
+        
+    Returns:
+        str: Name of the persona to reference in agent config
+    """
+    
+    # If persona_data is already a string, just return it
+    if isinstance(persona_data, str):
+        return persona_data
+        
+    # Validate persona data
+    if not isinstance(persona_data, dict):
+        raise HTTPException(
+            status_code=400,
+            detail='Persona data must be either a string name or a dictionary'
+        )
+    
+    persona_name = persona_data.get('name')
+    if not persona_name:
+        raise HTTPException(
+            status_code=400,
+            detail='Persona name required in persona data'
+        )
+    
+    # Create persona path
+    persona_path = Path('personas') / scope / persona_name / 'persona.json'
+    
+    # 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
+    
+    try:
+        # Create persona directory and save data
+        persona_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(persona_path, 'w') as f:
+            json.dump(persona_data, f, indent=2)
+        
+        logger.info(f"Successfully imported persona '{persona_name}' to {scope} scope")
+        return persona_name
+        
+    except Exception as e:
+        logger.error(f"Failed to import persona '{persona_name}': {str(e)}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to import persona: {str(e)}"
+        )

mindroot/coreplugins/admin/persona_router.py

@@ -0,0 +1,151 @@
+from fastapi import APIRouter, HTTPException, UploadFile, File, Form
+from pathlib import Path
+import json
+import shutil
+import traceback
+
+router = APIRouter()
+
+BASE_DIR = Path('personas')
+local_dir = BASE_DIR / "local"
+shared_dir = BASE_DIR / "shared"
+local_dir.mkdir(parents=True, exist_ok=True)
+shared_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']:
+        raise HTTPException(status_code=400, detail='Invalid scope')
+    persona_path = BASE_DIR / scope / name / 'persona.json'
+    if not persona_path.exists():
+        raise HTTPException(status_code=404, detail='Persona not found')
+    with open(persona_path, 'r') as f:
+        persona = json.load(f)
+    if 'moderated' not in persona:
+        persona['moderated'] = False
+    return persona
+
+@router.get('/personas/{scope}')
+def list_personas(scope: str):
+    if scope not in ['local', 'shared']:
+        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.post('/personas/{scope}')
+def create_persona(scope: str, persona: str = Form(...), faceref: UploadFile = File(None), avatar: UploadFile = File(None)):
+    try:
+        print("In create_persona")
+        print("scope is ", scope)
+        persona = json.loads(persona)
+
+        print("persona is ", persona)
+
+        if scope not in ['local', 'shared']:
+            raise HTTPException(status_code=400, detail='Invalid scope')
+        persona_name = persona.get('name')
+        if not persona_name:
+            raise HTTPException(status_code=400, detail='Persona name is required')
+        persona_path = BASE_DIR / scope / persona_name / 'persona.json'
+        if persona_path.exists():
+            raise HTTPException(status_code=400, detail='Persona already exists')
+        persona_path.parent.mkdir(parents=True, exist_ok=True)
+
+        target_dir = Path(__file__).resolve().parent.parent / 'static/personas' / persona_name
+
+        target_dir.mkdir(parents=True, exist_ok=True)
+        print('\033[93m' + str(target_dir) + '\033[0m')
+        if faceref:
+            print("Trying to save faceref")
+            faceref_path = persona_path.parent / 'faceref.png'
+            print("faceref path is ", faceref_path)
+            with open(faceref_path, 'wb') as f:
+                print("opened file for writing")
+                f.write(faceref.file.read())
+            # Copy faceref to new location
+            new_faceref_path = target_dir / 'faceref.png'
+            shutil.copy2(faceref_path, new_faceref_path)
+            persona['faceref'] = str(new_faceref_path)
+
+        if avatar:
+            print("Trying to save avatar")
+            avatar_path = persona_path.parent / 'avatar.png'
+            with open(avatar_path, 'wb') as f:
+                print("opened file for writing")
+                f.write(avatar.file.read())
+            # Copy avatar to new location
+            new_avatar_path = target_dir / 'avatar.png'
+            shutil.copy2(avatar_path, new_avatar_path)
+            persona['avatar'] = str(new_avatar_path)
+
+        with open(persona_path, 'w') as f:
+            json.dump(persona, f, indent=2)
+        return {'status': 'success'}
+
+    except Exception as e:
+        print("Error in create_persona")
+        raise HTTPException(status_code=500, detail='Internal server error ' + str(e))
+
+                
+@router.put('/personas/{scope}/{name}')
+def update_persona(scope: str, name:str, persona: str = Form(...), faceref: UploadFile = File(None), avatar: UploadFile = File(None)):
+     
+    try:
+        print("In update_persona")
+        print("scope is ", scope)
+        print("name is ", name)
+        print("BASE_DIR is ", BASE_DIR)
+        persona = json.loads(persona)
+        persona_name = persona.get('name')
+
+        print("persona is ", persona)
+        
+        if scope not in ['local', 'shared']:
+            raise HTTPException(status_code=400, detail='Invalid scope')
+        persona_path = BASE_DIR / scope / name / 'persona.json'
+        if not persona_path.exists():
+            raise HTTPException(status_code=404, detail='Persona not found')
+        if 'moderated' not in persona:
+            persona['moderated'] = False
+        
+        target_dir = Path(__file__).resolve().parent.parent / 'static/personas' / persona_name
+
+        target_dir.mkdir(parents=True, exist_ok=True)
+        print('\033[93m' + str(BASE_DIR) + '\033[0m')
+        print('\033[93m' + str(target_dir) + '\033[0m')
+ 
+        if faceref:
+            print("Trying to save faceref")
+            faceref_path = persona_path.parent / 'faceref.png'
+            print("faceref path is ", faceref_path)
+            with open(faceref_path, 'wb') as f:
+                print("opened file for writing")
+                f.write(faceref.file.read())
+            # Copy faceref to new location
+            new_faceref_path = target_dir / 'faceref.png'
+            shutil.copy2(faceref_path, new_faceref_path)
+            persona['faceref'] = str(new_faceref_path)
+        
+        if avatar:
+            print("Trying to save avatar")
+            avatar_path = persona_path.parent / 'avatar.png'
+            with open(avatar_path, 'wb') as f:
+                print("opened file for writing")
+                f.write(avatar.file.read())
+            # Copy avatar to new location
+            new_avatar_path = target_dir / 'avatar.png'
+            shutil.copy2(avatar_path, new_avatar_path)
+            persona['avatar'] = str(new_avatar_path)
+ 
+        with open(persona_path, 'w') as f:
+            json.dump(persona, f, indent=2)
+        return {'status': 'success'}
+    except Exception as e:
+        print("Error in update_persona")
+        print(str(e))
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail='Internal server error '+ str(e))
+