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

mindroot/coreplugins/admin/__init__.py

@@ -1 +1,3 @@
- # This file is required to make Python treat the directory as a package.
+# This file is required to make Python treat the directory as a package.
+# Import commands to register them
+from .mod import *

mindroot/coreplugins/admin/agent_router.py

@@ -1,4 +1,5 @@
 from fastapi import APIRouter, HTTPException, UploadFile, File, Form
+from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
 from pathlib import Path
 import json
@@ -7,6 +8,12 @@ from lib.providers.commands import command_manager
 from .persona_handler import handle_persona_import, import_persona_from_index
 import traceback
 import hashlib
+import zipfile
+import io
+import tempfile
+import time
+from typing import Dict, Any
+from datetime import datetime
 
 router = APIRouter()
 
@@ -16,13 +23,88 @@ shared_dir = BASE_DIR / "shared"
 local_dir.mkdir(parents=True, exist_ok=True)
 shared_dir.mkdir(parents=True, exist_ok=True)
 
+# Cache for agent ownership info
+_agent_ownership_cache = None
+_cache_timestamp = 0
+
 class GitHubImportRequest(BaseModel):
     repo_path: str  # Format: "owner/repo"
     scope: str
     tag: str = None
 
+def scan_agent_ownership() -> Dict[str, Any]:
+    """Scan all agents and build ownership information"""
+    ownership_info = {
+        'agents': {},
+        'scanned_at': datetime.now().isoformat(),
+        'total_agents': 0,
+        'owned_agents': 0,
+        'external_agents': 0
+    }
+    
+    # Scan both local and shared directories
+    for scope in ['local', 'shared']:
+        scope_dir = BASE_DIR / scope
+        if not scope_dir.exists():
+            continue
+            
+        for agent_dir in scope_dir.iterdir():
+            if not agent_dir.is_dir():
+                continue
+               
+            agent_json_path = agent_dir / 'agent.json'
+            if not agent_json_path.exists():
+                continue
+                
+            try:
+                with open(agent_json_path, 'r') as f:
+                    agent_data = json.load(f)
+                
+                agent_name = agent_data.get('name', agent_dir.name)
+                
+                # Extract ownership information
+                creator = agent_data.get('creator')
+                owner = agent_data.get('owner')
+                registry_owner = agent_data.get('registry_owner')
+                created_by = agent_data.get('created_by')
+                
+                # Determine if this agent has external ownership
+                has_external_owner = bool(creator or owner or registry_owner or created_by)
+                
+                ownership_info['agents'][f"{scope}/{agent_name}"] = {
+                    'name': agent_name,
+                    'scope': scope,
+                    'creator': creator,
+                    'owner': owner,
+                    'registry_owner': registry_owner,
+                    'created_by': created_by,
+                    'has_external_owner': has_external_owner,
+                    'description': agent_data.get('description', ''),
+                    'version': agent_data.get('version', '1.0.0')
+                }
+                
+                ownership_info['total_agents'] += 1
+                if has_external_owner:
+                    ownership_info['external_agents'] += 1
+                else:
+                    ownership_info['owned_agents'] += 1
+                    
+            except Exception as e:
+                print(f"Error reading agent {agent_dir.name}: {e}")
+                continue
+    
+    return ownership_info
+
 async def load_persona_data(persona_name: str) -> dict:
     """Load persona data from local or shared directory"""
+    # Handle registry personas: registry/owner/name
+    if persona_name.startswith('registry/'):
+        persona_path = Path(f'personas/{persona_name}/persona.json')
+        if persona_path.exists():
+            with open(persona_path, 'r') as f:
+                return json.load(f)
+    
+    # Fallback to existing local/shared pattern (UNCHANGED)
     persona_path = Path('personas/local') / persona_name / 'persona.json'
     if not persona_path.exists():
         persona_path = Path('personas/shared') / persona_name / 'persona.json'
@@ -91,12 +173,55 @@ 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]
+    agents = []
+    for p in scope_dir.iterdir():
+        if p.is_dir():
+            agent_json_path = p / 'agent.json'
+            if agent_json_path.exists():
+                try:
+                    with open(agent_json_path, 'r') as f:
+                        agent_data = json.load(f)
+                    agents.append(agent_data)
+                except Exception as e:
+                    # If we can't read the agent.json, just include the name
+                    agents.append({'name': p.name})
+    return agents
+
+@router.get('/agents/ownership-info')
+def get_agent_ownership_info():
+    """Get cached ownership information for all agents"""
+    global _agent_ownership_cache, _cache_timestamp
+    
+    # Cache for 5 minutes
+    cache_duration = 300  # 5 minutes in seconds
+    current_time = time.time()
+    
+    if (_agent_ownership_cache is None or 
+        current_time - _cache_timestamp > cache_duration):
+        
+        _agent_ownership_cache = scan_agent_ownership()
+        _cache_timestamp = current_time
+    
+    return _agent_ownership_cache
+
+@router.post('/agents/refresh-ownership-cache')
+def refresh_agent_ownership_cache():
+    """Force refresh of the agent ownership cache"""
+    global _agent_ownership_cache, _cache_timestamp
+    
+    _agent_ownership_cache = scan_agent_ownership()
+    _cache_timestamp = time.time()
+    
+    return {
+        'success': True,
+        'message': 'Agent ownership cache refreshed',
+        'data': _agent_ownership_cache
+    }
 
 @router.post('/agents/{scope}')
 def create_agent(scope: str, agent: str = Form(...)):
     try:
+        print(f"Creating agent in scope: {scope}")
         agent_data = json.loads(agent)
         if scope not in ['local', 'shared']:
             raise HTTPException(status_code=400, detail='Invalid scope')
@@ -105,6 +230,7 @@ def create_agent(scope: str, agent: str = Form(...)):
         if not agent_name:
             raise HTTPException(status_code=400, detail='Agent name is required')
 
+        print(f"Agent name: {agent_name}")
         if "indexName" in agent_data and agent_data["indexName"] is not None:
             print("Import agent from index: " + agent_data["indexName"])
             import_persona_from_index(agent_data["indexName"], agent_data['persona'])
@@ -112,8 +238,12 @@ def create_agent(scope: str, agent: str = Form(...)):
         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)
- 
+            # Extract owner information for registry personas
+            owner = agent_data.get('registry_owner') or agent_data.get('owner') or agent_data.get('creator')
+            persona_scope = 'registry' if owner else scope
+            
+            persona_name = handle_persona_import(agent_data['persona'], persona_scope, owner)
+            
             agent_data['persona'] = persona_name
         
         # Ensure recommended_plugins is present and is a list (also handle legacy required_plugins)
@@ -136,17 +266,26 @@ def create_agent(scope: str, agent: str = Form(...)):
             
         agent_path = BASE_DIR / scope / agent_name / 'agent.json'
         if agent_path.exists():
-            raise HTTPException(status_code=400, detail='Agent already exists')
+            # Check if overwrite parameter is provided
+            overwrite = agent_data.get('overwrite', False)
+            if not overwrite:
+                raise HTTPException(status_code=400, detail='Agent already exists')
+            else:
+                # If overwrite is True, we'll proceed to overwrite the existing agent
+                print(f"Overwriting existing agent: {agent_name}")
             
+        print(f"Creating agent directory: {agent_path.parent}")
         agent_path.parent.mkdir(parents=True, exist_ok=True)
+        print(f"Writing agent file: {agent_path}")
         with open(agent_path, 'w') as f:
             json.dump(agent_data, f, indent=2)
             
+        print(f"Successfully created agent: {agent_name}")
         return {'status': 'success'}
     except Exception as e:
         trace = traceback.format_exc()
-        raise HTTPException(status_code=500, detail='Internal server error ' + str(e) + "\n" + trace)
-
+        print(f"Error creating agent: {str(e)}\n{trace}")
+        raise HTTPException(status_code=500, detail=f'Internal server error: {str(e)}\nTrace: {trace}')
 @router.put('/agents/{scope}/{name}')
 def update_agent(scope: str, name: str, agent: str = Form(...)):
     try:
@@ -223,3 +362,107 @@ def import_github_agent_endpoint(request: GitHubImportRequest):
         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)}")
+
+@router.get('/agents/{scope}/{name}/export')
+def export_agent_zip(scope: str, name: str):
+    """Export an agent as a zip file"""
+    if scope not in ['local', 'shared']:
+        raise HTTPException(status_code=400, detail='Invalid scope')
+    
+    agent_dir = BASE_DIR / scope / name
+    if not agent_dir.exists():
+        raise HTTPException(status_code=404, detail='Agent not found')
+    
+    try:
+        # Create zip file in memory
+        zip_buffer = io.BytesIO()
+        
+        with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+            # Add all files from the agent directory
+            for file_path in agent_dir.rglob('*'):
+                if file_path.is_file():
+                    # Use relative path within the zip
+                    arcname = file_path.relative_to(agent_dir)
+                    zip_file.write(file_path, arcname)
+        
+        zip_buffer.seek(0)
+        
+        # Return as streaming response
+        return StreamingResponse(
+            io.BytesIO(zip_buffer.read()),
+            media_type='application/zip',
+            headers={'Content-Disposition': f'attachment; filename="{name}_agent.zip"'}
+        )
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error creating zip: {str(e)}")
+
+@router.post('/agents/{scope}/import-zip')
+async def import_agent_zip(scope: str, file: UploadFile = File(...)):
+    """Import an agent from a zip file"""
+    if scope not in ['local', 'shared']:
+        raise HTTPException(status_code=400, detail='Invalid scope')
+    
+    if not file.filename.endswith('.zip'):
+        raise HTTPException(status_code=400, detail='File must be a zip file')
+    
+    try:
+        # Read the uploaded file
+        content = await file.read()
+        
+        # Create a temporary directory for extraction
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+            
+            # Extract zip file
+            with zipfile.ZipFile(io.BytesIO(content), 'r') as zip_file:
+                zip_file.extractall(temp_path)
+            
+            # Find agent.json file
+            agent_json_files = list(temp_path.rglob('agent.json'))
+            if not agent_json_files:
+                raise HTTPException(status_code=400, detail='No agent.json found in zip file')
+            
+            agent_json_path = agent_json_files[0]
+            
+            # Load agent data
+            with open(agent_json_path, 'r') as f:
+                agent_data = json.load(f)
+            
+            agent_name = agent_data.get('name')
+            if not agent_name:
+                raise HTTPException(status_code=400, detail='Agent name not found in agent.json')
+            
+            # Check if agent already exists
+            target_dir = BASE_DIR / scope / agent_name
+            if target_dir.exists():
+                # For zip imports, we could add overwrite support in the future
+                # For now, we'll keep the existing behavior but make the error message consistent
+                raise HTTPException(
+                    status_code=400, 
+                    detail=f'Agent {agent_name} already exists. Use the registry manager for updates.'
+                )
+            
+            # Copy extracted files to target directory
+            target_dir.mkdir(parents=True, exist_ok=True)
+            
+            # Get the directory containing agent.json
+            source_dir = agent_json_path.parent
+            
+            # Copy all files from source to target
+            import shutil
+            for item in source_dir.rglob('*'):
+                if item.is_file():
+                    relative_path = item.relative_to(source_dir)
+                    target_file = target_dir / relative_path
+                    target_file.parent.mkdir(parents=True, exist_ok=True)
+                    shutil.copy2(item, target_file)
+        
+        return {
+            'success': True,
+            'message': f'Agent {agent_name} imported successfully',
+            'agent_name': agent_name
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error importing zip: {str(e)}")

mindroot/coreplugins/admin/asset_manager.py

@@ -0,0 +1,164 @@
+import hashlib
+import shutil
+from pathlib import Path
+from typing import Dict, Optional, Tuple
+import json
+import os
+
+class AssetManager:
+    """Manages deduplicated asset storage for personas"""
+    
+    def __init__(self, base_dir: str = "registry_assets"):
+        self.base_dir = Path(base_dir)
+        self.assets_dir = self.base_dir / "assets"
+        self.metadata_dir = self.base_dir / "metadata"
+        
+        # Create directories
+        self.assets_dir.mkdir(parents=True, exist_ok=True)
+        self.metadata_dir.mkdir(parents=True, exist_ok=True)
+    
+    def calculate_file_hash(self, file_path: Path) -> str:
+        """Calculate SHA256 hash of a file"""
+        sha256_hash = hashlib.sha256()
+        with open(file_path, "rb") as f:
+            for chunk in iter(lambda: f.read(4096), b""):
+                sha256_hash.update(chunk)
+        return sha256_hash.hexdigest()
+    
+    def calculate_content_hash(self, content: bytes) -> str:
+        """Calculate SHA256 hash of content bytes"""
+        return hashlib.sha256(content).hexdigest()
+    
+    def store_asset(self, source_path: Path, asset_type: str = "image") -> Tuple[str, bool]:
+        """Store an asset and return (hash, was_new)"""
+        if not source_path.exists():
+            raise FileNotFoundError(f"Source file not found: {source_path}")
+        
+        # Calculate hash
+        file_hash = self.calculate_file_hash(source_path)
+        asset_path = self.assets_dir / file_hash
+        
+        # Check if asset already exists
+        if asset_path.exists():
+            # Update reference count
+            self._increment_reference_count(file_hash)
+            return file_hash, False
+        
+        # Copy file to assets directory
+        shutil.copy2(source_path, asset_path)
+        
+        # Create metadata
+        metadata = {
+            "hash": file_hash,
+            "type": asset_type,
+            "size": source_path.stat().st_size,
+            "original_name": source_path.name,
+            "reference_count": 1
+        }
+        
+        metadata_path = self.metadata_dir / f"{file_hash}.json"
+        with open(metadata_path, 'w') as f:
+            json.dump(metadata, f, indent=2)
+        
+        return file_hash, True
+    
+    def store_content(self, content: bytes, filename: str, asset_type: str = "image") -> Tuple[str, bool]:
+        """Store content bytes and return (hash, was_new)"""
+        file_hash = self.calculate_content_hash(content)
+        asset_path = self.assets_dir / file_hash
+        
+        # Check if asset already exists
+        if asset_path.exists():
+            self._increment_reference_count(file_hash)
+            return file_hash, False
+        
+        # Write content to assets directory
+        with open(asset_path, 'wb') as f:
+            f.write(content)
+        
+        # Create metadata
+        metadata = {
+            "hash": file_hash,
+            "type": asset_type,
+            "size": len(content),
+            "original_name": filename,
+            "reference_count": 1
+        }
+        
+        metadata_path = self.metadata_dir / f"{file_hash}.json"
+        with open(metadata_path, 'w') as f:
+            json.dump(metadata, f, indent=2)
+        
+        return file_hash, True
+    
+    def get_asset_path(self, file_hash: str) -> Optional[Path]:
+        """Get the path to an asset by hash"""
+        asset_path = self.assets_dir / file_hash
+        return asset_path if asset_path.exists() else None
+    
+    def get_asset_metadata(self, file_hash: str) -> Optional[Dict]:
+        """Get metadata for an asset"""
+        metadata_path = self.metadata_dir / f"{file_hash}.json"
+        if not metadata_path.exists():
+            return None
+        
+        with open(metadata_path, 'r') as f:
+            return json.load(f)
+    
+    def _increment_reference_count(self, file_hash: str):
+        """Increment reference count for an asset"""
+        metadata = self.get_asset_metadata(file_hash)
+        if metadata:
+            metadata['reference_count'] += 1
+            metadata_path = self.metadata_dir / f"{file_hash}.json"
+            with open(metadata_path, 'w') as f:
+                json.dump(metadata, f, indent=2)
+    
+    def decrement_reference_count(self, file_hash: str) -> bool:
+        """Decrement reference count and delete if zero. Returns True if deleted."""
+        metadata = self.get_asset_metadata(file_hash)
+        if not metadata:
+            return False
+        
+        metadata['reference_count'] -= 1
+        
+        if metadata['reference_count'] <= 0:
+            # Delete asset and metadata
+            asset_path = self.assets_dir / file_hash
+            metadata_path = self.metadata_dir / f"{file_hash}.json"
+            
+            if asset_path.exists():
+                asset_path.unlink()
+            if metadata_path.exists():
+                metadata_path.unlink()
+            
+            return True
+        else:
+            # Update metadata
+            metadata_path = self.metadata_dir / f"{file_hash}.json"
+            with open(metadata_path, 'w') as f:
+                json.dump(metadata, f, indent=2)
+            
+            return False
+    
+    def get_stats(self) -> Dict:
+        """Get storage statistics"""
+        total_assets = len(list(self.assets_dir.glob('*')))
+        total_size = sum(f.stat().st_size for f in self.assets_dir.glob('*'))
+        
+        # Calculate total references
+        total_references = 0
+        for metadata_file in self.metadata_dir.glob('*.json'):
+            with open(metadata_file, 'r') as f:
+                metadata = json.load(f)
+                total_references += metadata.get('reference_count', 0)
+        
+        return {
+            'total_assets': total_assets,
+            'total_size_bytes': total_size,
+            'total_references': total_references,
+            'deduplication_ratio': total_references / max(total_assets, 1)
+        }
+
+# Global asset manager instance
+asset_manager = AssetManager()