python-alfresco-mcp-server 1.1.0__py3-none-any.whl

alfresco_mcp_server/tools/core/get_node_properties.py

@@ -0,0 +1,195 @@
+"""
+Get node properties tool for Alfresco MCP Server.
+Self-contained tool for retrieving document/folder metadata and properties.
+"""
+import logging
+from typing import Optional
+from fastmcp import Context
+
+from ...utils.connection import ensure_connection, get_core_client
+
+logger = logging.getLogger(__name__)
+
+
+async def get_node_properties_impl(node_id: str, ctx: Optional[Context] = None) -> str:
+    """Get metadata and properties of a document or folder.
+    
+    Args:
+        node_id: Node ID to get properties for
+        ctx: MCP context for progress reporting
+    
+    Returns:
+        Formatted node properties and metadata
+    """
+    if ctx:
+        await ctx.info(f"Getting properties for: {node_id}")
+        await ctx.report_progress(0.1)
+    
+    if not node_id.strip():
+        return "ERROR: node_id is required"
+    
+    try:
+        # Ensure connection and get core client
+        await ensure_connection()
+        core_client = await get_core_client()
+        
+        # Clean the node ID (remove any URL encoding or extra characters)
+        clean_node_id = node_id.strip()
+        if clean_node_id.startswith('alfresco://'):
+            # Extract node ID from URI format
+            clean_node_id = clean_node_id.split('/')[-1]
+        
+        logger.info(f"Getting properties for node: {clean_node_id}")
+        
+        if ctx:
+            await ctx.report_progress(0.5)
+        
+        # Get node metadata using core client
+        node_response = core_client.nodes.get(
+            node_id=clean_node_id,
+            include=["properties", "permissions", "path"]
+        )
+        
+        if not hasattr(node_response, 'entry'):
+            return f"ERROR: Failed to get node information for: {clean_node_id}"
+        
+        node_info = node_response.entry
+        
+        # Extract basic properties - use correct Python attribute names
+        filename = getattr(node_info, 'name', 'Unknown')
+        node_type_raw = getattr(node_info, 'node_type', 'Unknown')
+        created_at = getattr(node_info, 'created_at', 'Unknown')
+        modified_at = getattr(node_info, 'modified_at', 'Unknown')
+        
+        # Clean up node_type display - convert enum to string
+        node_type = 'Unknown'
+        if node_type_raw != 'Unknown':
+            if hasattr(node_type_raw, 'value'):
+                node_type = node_type_raw.value  # For enum objects
+            else:
+                node_type = str(node_type_raw)  # For string objects
+        
+        # Extract creator and modifier information - use correct attribute names
+        creator = 'Unknown'
+        modifier = 'Unknown'
+        if hasattr(node_info, 'created_by_user') and node_info.created_by_user:
+            creator = getattr(node_info.created_by_user, 'display_name', 'Unknown')
+        if hasattr(node_info, 'modified_by_user') and node_info.modified_by_user:
+            modifier = getattr(node_info.modified_by_user, 'display_name', 'Unknown')
+        
+        # Extract size information - use correct attribute names
+        size_str = 'Unknown'
+        if hasattr(node_info, 'content') and node_info.content:
+            size_bytes = getattr(node_info.content, 'size_in_bytes', 0)
+            if size_bytes > 0:
+                if size_bytes > 1024 * 1024:
+                    size_str = f"{size_bytes / (1024 * 1024):.1f} MB"
+                elif size_bytes > 1024:
+                    size_str = f"{size_bytes / 1024:.1f} KB"
+                else:
+                    size_str = f"{size_bytes} bytes"
+        
+        # Extract MIME type - use correct attribute names
+        mime_type = 'Unknown'
+        if hasattr(node_info, 'content') and node_info.content:
+            mime_type = getattr(node_info.content, 'mime_type', 'Unknown')
+        
+        # Extract path information - use correct attribute names
+        path = 'Unknown'
+        if hasattr(node_info, 'path') and node_info.path:
+            path = getattr(node_info.path, 'name', 'Unknown')
+        
+        # Extract custom properties - try multiple access methods
+        title = 'Unknown'
+        description = 'Unknown'
+        author = 'Unknown'
+        if hasattr(node_info, 'properties') and node_info.properties:
+            try:
+                # Try to_dict() method first
+                if hasattr(node_info.properties, 'to_dict'):
+                    props_dict = node_info.properties.to_dict()
+                    title = props_dict.get('cm:title', 'Unknown')
+                    description = props_dict.get('cm:description', 'Unknown') 
+                    author = props_dict.get('cm:author', 'Unknown')
+                    logger.info(f"Properties found via to_dict(): title={title}, description={description}, author={author}")
+                # Try direct attribute access
+                elif hasattr(node_info.properties, 'cm_title') or hasattr(node_info.properties, 'cm:title'):
+                    title = getattr(node_info.properties, 'cm_title', getattr(node_info.properties, 'cm:title', 'Unknown'))
+                    description = getattr(node_info.properties, 'cm_description', getattr(node_info.properties, 'cm:description', 'Unknown'))
+                    author = getattr(node_info.properties, 'cm_author', getattr(node_info.properties, 'cm:author', 'Unknown'))
+                    logger.info(f"Properties found via attributes: title={title}, description={description}, author={author}")
+                # Try dict-like access
+                elif hasattr(node_info.properties, '__getitem__'):
+                    title = node_info.properties.get('cm:title', 'Unknown') if hasattr(node_info.properties, 'get') else node_info.properties['cm:title'] if 'cm:title' in node_info.properties else 'Unknown'
+                    description = node_info.properties.get('cm:description', 'Unknown') if hasattr(node_info.properties, 'get') else node_info.properties['cm:description'] if 'cm:description' in node_info.properties else 'Unknown'
+                    author = node_info.properties.get('cm:author', 'Unknown') if hasattr(node_info.properties, 'get') else node_info.properties['cm:author'] if 'cm:author' in node_info.properties else 'Unknown'
+                    logger.info(f"Properties found via dict access: title={title}, description={description}, author={author}")
+                else:
+                    logger.warning(f"Properties object type: {type(node_info.properties)}, available methods: {dir(node_info.properties)}")
+            except Exception as props_error:
+                logger.error(f"Error accessing properties: {props_error}")
+        else:
+            logger.warning("No properties found on node_info")
+        
+        # Determine if it's a folder and if it's locked - use correct attribute names
+        is_folder = 'Yes' if node_type == 'cm:folder' else 'No'
+        is_locked = 'Unknown'
+        if hasattr(node_info, 'is_locked'):
+            is_locked = 'Yes' if node_info.is_locked else 'No'
+        
+        # Version information - use correct attribute names
+        version = 'Unknown'
+        if hasattr(node_info, 'properties') and node_info.properties:
+            if hasattr(node_info.properties, 'to_dict'):
+                props_dict = node_info.properties.to_dict()
+                version = props_dict.get('cm:versionLabel', 'Unknown')
+        
+        logger.info(f"Retrieved properties for: {filename}")
+        
+        if ctx:
+            await ctx.report_progress(1.0)
+        
+        # Clean JSON-friendly formatting (no markdown syntax)
+        # Only show properties that exist and have meaningful values
+        result = f"Node Properties for: {filename}\n\n"
+        result += f"Node ID: {clean_node_id}\n"
+        result += f"Name: {filename}\n"
+        
+        # Only show properties that exist and aren't "Unknown"
+        if path and path != 'Unknown':
+            result += f"Path: {path}\n"
+        if node_type and node_type != 'Unknown':
+            result += f"Type: {node_type}\n"
+        if created_at and created_at != 'Unknown':
+            result += f"Created: {created_at}\n"
+        if modified_at and modified_at != 'Unknown':
+            result += f"Modified: {modified_at}\n"
+        if creator and creator != 'Unknown':
+            result += f"Creator: {creator}\n"
+        if modifier and modifier != 'Unknown':
+            result += f"Modifier: {modifier}\n"
+        if size_str and size_str != 'Unknown':
+            result += f"Size: {size_str}\n"
+        if mime_type and mime_type != 'Unknown':
+            result += f"MIME Type: {mime_type}\n"
+        if title and title != 'Unknown':
+            result += f"Title: {title}\n"
+        if description and description != 'Unknown':
+            result += f"Description: {description}\n"
+        if author and author != 'Unknown':
+            result += f"Author: {author}\n"
+        if is_folder and is_folder != 'Unknown':
+            result += f"Is Folder: {is_folder}\n"
+        if is_locked and is_locked != 'Unknown':
+            result += f"Is Locked: {is_locked}\n"
+        if version and version != 'Unknown':
+            result += f"Version: {version}\n"
+        
+        return result
+        
+    except Exception as e:
+        error_msg = f"ERROR: Failed to get properties: {str(e)}"
+        if ctx:
+            await ctx.error(error_msg)
+        logger.error(f"Get properties failed: {e}")
+        return error_msg 

alfresco_mcp_server/tools/core/update_node_properties.py

@@ -0,0 +1,138 @@
+"""
+Update node properties tool for Alfresco MCP Server.
+Self-contained tool for updating document/folder metadata and properties.
+"""
+import logging
+import os
+from typing import Optional
+from fastmcp import Context
+
+from ...utils.connection import ensure_connection, get_core_client
+
+logger = logging.getLogger(__name__)
+
+
+async def update_node_properties_impl(
+    node_id: str,
+    name: str = "",
+    title: str = "",
+    description: str = "",
+    author: str = "",
+    ctx: Optional[Context] = None
+) -> str:
+    """Update metadata and properties of a document or folder.
+    
+    Args:
+        node_id: Node ID to update (required)
+        name: New name for the node (optional)
+        title: Document title (cm:title) (optional)
+        description: Document description (cm:description) (optional)
+        author: Document author (cm:author) (optional)
+        ctx: MCP context for progress reporting
+    
+    Returns:
+        Update confirmation with changes made
+    """
+    if ctx:
+        await ctx.info(f"Updating properties for: {node_id}")
+        await ctx.report_progress(0.1)
+    
+    if not node_id.strip():
+        return "ERROR: node_id is required"
+    
+    if not any([name, title, description, author]):
+        return "ERROR: At least one property (name, title, description, or author) must be provided"
+    
+    try:
+        # Ensure connection and get core client
+        await ensure_connection()
+        core_client = await get_core_client()
+        
+        # Clean the node ID (remove any URL encoding or extra characters)
+        clean_node_id = node_id.strip()
+        if clean_node_id.startswith('alfresco://'):
+            # Extract node ID from URI format
+            clean_node_id = clean_node_id.split('/')[-1]
+        
+        logger.info(f"Updating properties for node: {clean_node_id}")
+        
+        if ctx:
+            await ctx.report_progress(0.3)
+        
+        # Get node information first to validate it exists
+        try:
+            node_response = core_client.nodes.get(node_id=clean_node_id)
+            if not hasattr(node_response, 'entry'):
+                return f"ERROR: Failed to get node information for: {clean_node_id}"
+            
+            node_info = node_response.entry
+            current_name = getattr(node_info, 'name', f"document_{clean_node_id}")
+            
+        except Exception as get_error:
+            return f"ERROR: Failed to validate node {clean_node_id}: {str(get_error)}"
+        
+        if ctx:
+            await ctx.report_progress(0.5)
+        
+        # Prepare updates for actual API call
+        properties_updates = {}
+        if title and title.strip():
+            properties_updates['cm:title'] = title.strip()
+        if description and description.strip():
+            properties_updates['cm:description'] = description.strip()
+        if author and author.strip():
+            properties_updates['cm:author'] = author.strip()
+        
+        # Import the UpdateNodeRequest model
+        try:
+            from python_alfresco_api.clients.core.nodes.models import UpdateNodeRequest
+        except ImportError:
+            return "ERROR: Failed to import UpdateNodeRequest model"
+        
+        # Prepare update request
+        update_request = UpdateNodeRequest()
+        
+        if name and name.strip():
+            update_request.name = name.strip()
+        if properties_updates:
+            update_request.properties = properties_updates
+            
+        if ctx:
+            await ctx.report_progress(0.7)
+        
+        # Use the core client's update method
+        try:
+            updated_node = core_client.nodes.update(
+                node_id=clean_node_id,
+                request=update_request
+            )
+            logger.info("Node properties updated successfully")
+            
+        except Exception as update_error:
+            logger.error(f"Update failed: {update_error}")
+            return f"ERROR: Update failed: {str(update_error)}"
+
+        if ctx:
+            await ctx.report_progress(1.0)
+        
+        changes = []
+        if name:
+            changes.append(f"- Name: {name}")
+        if title:
+            changes.append(f"- Title: {title}")
+        if description:
+            changes.append(f"- Description: {description}")
+        if author:
+            changes.append(f"- Author: {author}")
+        
+        updated_properties = "\n".join(changes)
+        
+        # Clean JSON-friendly formatting (no markdown syntax)
+        return f"Node Updated Successfully\n\nNode ID: {clean_node_id}\nUpdated Properties:\n{updated_properties}\nUpdate completed successfully"
+        
+    except Exception as e:
+        error_msg = f"ERROR: Update failed: {str(e)}"
+        if ctx:
+            await ctx.error(error_msg)
+        logger.error(f"Update failed: {e}")
+        return error_msg 

alfresco_mcp_server/tools/core/upload_document.py

@@ -0,0 +1,244 @@
+"""
+Upload document tool for Alfresco MCP Server.
+Self-contained tool for uploading documents to Alfresco repository.
+"""
+import logging
+import os
+import base64
+import tempfile
+from typing import Optional
+from fastmcp import Context
+
+from ...utils.connection import ensure_connection, get_core_client
+from ...utils.json_utils import safe_format_output
+from ...utils.file_type_analysis import detect_file_extension_from_content
+
+logger = logging.getLogger(__name__)
+
+
+# Add this TEMPORARILY to your MCP server code:
+def create_and_upload_file_share_style_temp(
+    core_client,
+    file_path,
+    parent_id="-my-",
+    filename=None,
+    description=None,
+    custom_title=None
+):
+    """
+    TEMPORARY: Share-style upload until next python-alfresco-api release.
+    Creates version 1.0 with full path as title (for real files) or custom title (for base64).
+    """
+    from pathlib import Path
+    from python_alfresco_api.utils import content_utils
+    
+    file_path_obj = Path(file_path)
+    upload_filename = filename or file_path_obj.name
+    
+    # Build properties with appropriate title
+    if custom_title:
+        # Use custom title for base64 uploads (just filename, not temp path)
+        properties = {"cm:title": custom_title}
+    else:
+        # Use full path for real file uploads (Share-style behavior)
+        properties = {"cm:title": str(file_path_obj)}
+    
+    if description:
+        properties["cm:description"] = description
+    
+    # Use existing content_utils.upload_file (already in current package)
+    return content_utils.upload_file(
+        core_client=core_client,
+        file_path=file_path_obj,
+        parent_id=parent_id,
+        filename=upload_filename,
+        description=description,
+        properties=properties,
+        auto_rename=True
+    )
+
+
+async def upload_document_impl(
+    file_path: str = "",
+    base64_content: str = "",
+    parent_id: str = "-shared-",
+    description: str = "",
+    ctx: Optional[Context] = None
+) -> str:
+    """Upload a document to Alfresco using Share-style behavior.
+    
+    Args:
+        file_path: Path to the file to upload (alternative to base64_content)
+        base64_content: Base64 encoded file content (alternative to file_path)
+        parent_id: Parent folder ID (default: shared folder)
+        description: Document description (optional)
+        ctx: MCP context for progress reporting
+    
+    Note:
+        - Uploads as version 1.0 (matching Alfresco Share behavior)
+        - Uses full file path as title (matching Alfresco Share behavior)
+        - Original filename is preserved automatically
+        - For base64 uploads: content type detection and auto-naming
+        - Cross-platform support: Windows paths with quotes, macOS ~/path expansion, Linux XDG directories
+        - File extension detection works on all platforms (including macOS hidden extensions)
+        - Linux filesystem case-sensitivity and permission handling
+    
+    Returns:
+        Upload confirmation with document details
+    """
+    if ctx:
+        if file_path:
+            await ctx.info(f">> Uploading document from '{file_path}' to {parent_id}")
+        else:
+            await ctx.info(f">> Uploading base64 content to {parent_id}")
+        await ctx.info("Validating file and parameters...")
+        await ctx.report_progress(0.1)
+    
+    # Determine upload mode and validate
+    use_base64 = bool(base64_content.strip())
+    use_file_path = bool(file_path.strip())
+    
+    if not use_base64 and not use_file_path:
+        return "ERROR: Must provide either file_path or base64_content"
+    
+    if use_base64 and use_file_path:
+        return "ERROR: Cannot use both file_path and base64_content - choose one"
+    
+    # Variables for upload
+    actual_file_path = None
+    temp_file_path = None
+    final_filename = None
+    
+    try:
+        if use_file_path:
+            # Handle file path upload - cross-platform path handling
+            cleaned_file_path = file_path.strip().strip('"').strip("'")
+            
+            # Handle macOS/Unix path expansion (~/Documents, etc.)
+            if cleaned_file_path.startswith('~'):
+                cleaned_file_path = os.path.expanduser(cleaned_file_path)
+            
+            abs_file_path = os.path.abspath(cleaned_file_path)
+            
+            if not os.path.exists(abs_file_path):
+                if os.path.exists(cleaned_file_path):
+                    abs_file_path = cleaned_file_path
+                else:
+                    return f"ERROR: File not found: {cleaned_file_path} (cleaned from: {file_path})"
+            
+            if not os.path.isfile(abs_file_path):
+                return f"ERROR: Path is not a file: {abs_file_path}"
+            
+            # Linux-specific: Check file permissions
+            if not os.access(abs_file_path, os.R_OK):
+                return f"ERROR: File not readable (permission denied): {abs_file_path}"
+                
+            actual_file_path = abs_file_path
+            final_filename = os.path.basename(abs_file_path)
+            
+        else:
+            # Handle base64 content upload - create temporary file
+            try:
+                file_content = base64.b64decode(base64_content)
+                
+                # Detect content type and create appropriate filename
+                detected_extension = detect_file_extension_from_content(file_content)
+                final_filename = f"uploaded_document{detected_extension or ''}"
+                
+                # Create temporary file with decoded content
+                temp_fd, temp_file_path = tempfile.mkstemp(suffix=f"_{final_filename}")
+                try:
+                    with os.fdopen(temp_fd, 'wb') as temp_file:
+                        temp_file.write(file_content)
+                    actual_file_path = temp_file_path
+                except Exception:
+                    os.close(temp_fd)  # Close if writing failed
+                    raise
+                
+            except Exception as decode_error:
+                return f"ERROR: Invalid base64 content or file creation failed: {str(decode_error)}"
+        
+        if not actual_file_path:
+            return "ERROR: No valid file path available for upload"
+            
+    except Exception as validation_error:
+        return f"ERROR: Validation failed: {str(validation_error)}"
+    
+    try:
+        # Ensure connection and get core client
+        await ensure_connection()
+        core_client = await get_core_client()
+        
+        if not core_client.is_initialized:
+            return safe_format_output("❌ Error: Alfresco server unavailable")
+        
+        if ctx:
+            await ctx.info("Creating and uploading document using Share-style approach...")
+            await ctx.report_progress(0.5)
+        
+        logger.debug(f"Uploading '{final_filename}' to parent {parent_id} using Share-style function")
+        
+        # Determine title based on upload type
+        custom_title = None
+        if use_base64:
+            # For base64 uploads, use just the filename as title (not temp file path)
+            custom_title = final_filename
+        # For file path uploads, let Share-style function use full path as title
+        
+        # Use Share-style upload function
+        result = create_and_upload_file_share_style_temp(
+            core_client=core_client,
+            file_path=actual_file_path,
+            parent_id=parent_id,
+            filename=final_filename,
+            description=description or None,
+            custom_title=custom_title
+        )
+        
+        # Extract essential info
+        if hasattr(result, 'entry') and result.entry:
+            node_id = getattr(result.entry, 'id', 'Unknown')
+            node_name = getattr(result.entry, 'name', final_filename)
+            logger.info(f"Upload completed: {node_name} -> {node_id}")
+        else:
+            logger.info(f"Upload completed successfully")
+        
+        if ctx:
+            await ctx.info("Upload completed successfully!")
+            await ctx.report_progress(1.0)
+
+        # Format result for MCP with clean JSON-friendly output
+        title_info = custom_title if custom_title else "Full file path"
+        upload_type = "Base64 content" if use_base64 else "File path"
+        
+        success_result = f"""SUCCESS: Document Uploaded Successfully!
+
+Name: {final_filename}
+Parent: {parent_id}
+Title: {title_info}
+Description: {description or 'N/A'}
+Upload Type: {upload_type}
+
+Details: {result}
+
+✨ Share-Style Upload: Version 1.0, proper title handling for upload type
+✨ File path uploads: Full path as title (matching Alfresco Share)
+✨ Base64 uploads: Clean filename as title (no temp file paths)"""
+        
+        return success_result
+        
+    except Exception as e:
+        error_msg = f"ERROR: Document upload failed: {str(e)}"
+        if ctx:
+            await ctx.error(error_msg)
+        logger.error(f"Document upload failed: {e}")
+        return error_msg
+        
+    finally:
+        # Clean up temporary file if created
+        if temp_file_path and os.path.exists(temp_file_path):
+            try:
+                os.unlink(temp_file_path)
+                logger.debug(f"Cleaned up temporary file: {temp_file_path}")
+            except Exception as cleanup_error:
+                logger.warning(f"Failed to clean up temporary file {temp_file_path}: {cleanup_error}") 

alfresco_mcp_server/tools/search/__init__.py

@@ -0,0 +1,15 @@
+# Search tools module
+
+from . import (
+    advanced_search,
+    cmis_search,
+    search_by_metadata,
+    search_content,
+)
+
+__all__ = [
+    "advanced_search",
+    "cmis_search", 
+    "search_by_metadata",
+    "search_content",
+]