pathgate 0.1.0__py3-none-any.whl

pathgate/config.py

@@ -0,0 +1,40 @@
+from pathlib import Path
+import os
+import logging
+from mcp.server import Server
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[logging.StreamHandler()]
+)
+logger = logging.getLogger(__name__)
+
+# Create the MCP server
+server = Server("pathgate")
+
+
+# pathgate/config.py
+ALLOWED_PATHS: list[str] = []   # filled in by configure() at startup
+_state = {"read_only": False}
+
+def configure(paths: list[str], read_only: bool) -> None:
+    ALLOWED_PATHS.clear()
+    ALLOWED_PATHS.extend(paths)      # mutate in place so existing imports see it
+    _state["read_only"] = read_only
+
+def is_read_only() -> bool:
+    return _state["read_only"]
+
+
+def is_path_allowed(path):
+    abs_path = os.path.realpath(path)  # resolves symlinks too
+    for allowed in ALLOWED_PATHS:
+        allowed_normalized = os.path.realpath(allowed)
+        # Ensure that the allowed path ends with separator before prefix check
+        if not allowed_normalized.endswith(os.sep):
+            allowed_normalized += os.sep
+        # check exact match
+        if abs_path == os.path.realpath(allowed) or abs_path.startswith(allowed_normalized):
+            return True
+    return False

pathgate/prompts.py

@@ -0,0 +1,84 @@
+from pathgate.config import server
+from mcp.types import (TextContent, GetPromptResult, ListPromptsResult, PromptMessage, Prompt)
+
+@server.list_prompts()
+async def list_prompts() -> ListPromptsResult:
+    """List available prompts"""
+    prompts = [
+        Prompt(
+            name="analyze_directory",
+            description="Generate a prompt to analyze a directory structure",
+            arguments=[
+                {
+                    "name": "directory",
+                    "description": "Directory path to analyze",
+                    "required": True
+                }
+            ]
+        ),
+        Prompt(
+            name="find_and_read",
+            description="Generate a prompt to find and read files matching a pattern",
+            arguments=[
+                {
+                    "name": "directory",
+                    "description": "Directory to search in", 
+                    "required": True
+                },
+                {
+                    "name": "pattern",
+                    "description": "File pattern to search for",
+                    "required": True
+                }
+            ]
+        )
+    ]
+    
+    return ListPromptsResult(prompts=prompts)
+
+@server.get_prompt()
+async def get_prompt(name: str, arguments: dict) -> GetPromptResult:
+    """Get a prompt"""
+    if name == "analyze_directory":
+        directory = arguments["directory"]
+        content = f"""Please analyze the directory structure at: {directory}
+
+Use the list_directory_tool to explore the directory and provide insights about:
+1. Total number of files and directories
+2. File types and their distribution
+3. Largest files
+4. Directory organization
+5. Any potential issues or recommendations"""
+        
+        return GetPromptResult(
+            description=f"Analysis prompt for directory: {directory}",
+            messages=[
+                PromptMessage(
+                    role="user",
+                    content=TextContent(type="text", text=content)
+                )
+            ]
+        )
+    
+    elif name == "find_and_read":
+        directory = arguments["directory"]
+        pattern = arguments["pattern"]
+        content = f"""Please find and read files in: {directory}
+Pattern: {pattern}
+
+1. Use search_files_tool to find matching files
+2. Use read_file_tool to read the contents
+3. Provide a summary of what you found"""
+        
+        return GetPromptResult(
+            description=f"Find and read prompt for {pattern} in {directory}",
+            messages=[
+                PromptMessage(
+                    role="user",
+                    content=TextContent(type="text", text=content)
+                )
+            ]
+        )
+    
+    else:
+        raise ValueError(f"Unknown prompt: {name}")

pathgate/resources.py

@@ -0,0 +1,90 @@
+from pathgate.config import server, is_path_allowed
+from mcp.types import (Resource, ListResourcesResult, ReadResourceResult, TextContent)
+import os
+import json
+
+# RESOURCES HANDLERS
+@server.list_resources()
+async def list_resources() -> ListResourcesResult:
+    """List available resources"""
+    resources = [
+        Resource(
+            uri="file://*",
+            name="File Contents",
+            description="Read the contents of any file by providing its path",
+            mimeType="text/plain"
+        ),
+        Resource(
+            uri="directory://*",
+            name="Directory Listing",
+            description="List the contents of any directory by providing its path",
+            mimeType="application/json"
+        )
+    ]
+    
+    return ListResourcesResult(resources=resources)
+
+@server.read_resource()
+async def read_resource(uri: str) -> ReadResourceResult:
+    """Read a resource"""
+    if uri.startswith("file://"):
+        path = uri[7:]  # Remove "file://" prefix
+        
+        if not is_path_allowed(path):
+            return ReadResourceResult(
+                contents=[TextContent(type="text", text=f"Error: Access denied to {path}")]
+            )
+        
+        if not os.path.exists(path) or not os.path.isfile(path):
+            return ReadResourceResult(
+                contents=[TextContent(type="text", text=f"Error: File not found or not a file: {path}")]
+            )
+        
+        try:
+            with open(path, 'r', encoding='utf-8') as f:
+                content = f.read()
+            return ReadResourceResult(
+                contents=[TextContent(type="text", text=content)]
+            )
+        except Exception as e:
+            return ReadResourceResult(
+                contents=[TextContent(type="text", text=f"Error reading file: {str(e)}")]
+            )
+    
+    elif uri.startswith("directory://"):
+        path = uri[12:]  # Remove "directory://" prefix
+        
+        if not is_path_allowed(path):
+            return ReadResourceResult(
+                contents=[TextContent(type="text", text=f"Error: Access denied to {path}")]
+            )
+        
+        if not os.path.exists(path) or not os.path.isdir(path):
+            return ReadResourceResult(
+                contents=[TextContent(type="text", text=f"Error: Directory not found or not a directory: {path}")]
+            )
+        
+        try:
+            entries = []
+            for item in os.listdir(path):
+                item_path = os.path.join(path, item)
+                stat = os.stat(item_path)
+                entries.append({
+                    "name": item,
+                    "type": "directory" if os.path.isdir(item_path) else "file",
+                    "size": stat.st_size,
+                    "modified": stat.st_mtime
+                })
+            
+            return ReadResourceResult(
+                contents=[TextContent(type="text", text=json.dumps(entries, indent=2))]
+            )
+        except Exception as e:
+            return ReadResourceResult(
+                contents=[TextContent(type="text", text=f"Error listing directory: {str(e)}")]
+            )
+    
+    else:
+        return ReadResourceResult(
+            contents=[TextContent(type="text", text="Error: Unsupported resource URI")]
+        )

pathgate/server.py

@@ -0,0 +1,42 @@
+from pathgate.config import configure, server
+from mcp.server.stdio import stdio_server
+from pathgate import tools, resources, prompts, tool_schemas
+import asyncio
+import os
+import argparse
+from pathlib import Path
+
+server.list_tools()(tool_schemas.list_tools)
+server.call_tool()(tools.call_tool)
+server.list_resources()(resources.list_resources)
+server.read_resource()(resources.read_resource)
+server.list_prompts()(prompts.list_prompts)
+server.get_prompt()(prompts.get_prompt)
+
+def parse_args(argv=None):
+    p = argparse.ArgumentParser(prog="filesystem-mcp-server")
+    p.add_argument("paths", nargs="*", help="Directories the server may access")
+    p.add_argument("--read-only", action="store_true", help="Disable write/delete/move/copy tools")
+    args = p.parse_args(argv)
+
+    env_paths = [x for x in os.environ.get("FS_MCP_ALLOWED_PATHS", "").split(os.pathsep) if x]
+    raw = args.paths or env_paths
+    if not raw:
+        p.error("no allowed directories given. Pass at least one path "
+                "or set FS_MCP_ALLOWED_PATHS.")
+
+    paths = [str(Path(x).expanduser().resolve()) for x in raw]
+    for x in paths:
+        if not Path(x).is_dir():
+            p.error(f"not a directory: {x}")
+    return paths, args.read_only
+
+async def main():
+    async with stdio_server() as (read_stream, write_stream):
+        await server.run(read_stream, write_stream, server.create_initialization_options())
+
+if __name__ == "__main__":
+    paths, read_only = parse_args()
+    configure(paths, read_only)
+    asyncio.run(main())
+

pathgate/tool_schemas.py

@@ -0,0 +1,191 @@
+from pathgate.config import server
+from mcp.types import Tool, ListToolsResult
+
+@server.list_tools()
+async def list_tools() -> ListToolsResult:
+    """List available tools"""
+    tools = [
+        Tool(
+            name="read_file_tool",
+            description="Read the contents of a file",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "path": {
+                        "type": "string", 
+                        "description": "Absolute or relative path to the file"
+                    },
+                    "encoding": {
+                        "type": "string",
+                        "description": "File encoding (default: utf-8)",
+                        "default": "utf-8"
+                    }
+                },
+                "required": ["path"]
+            }
+        ),
+        Tool(
+            name="write_file_tool",
+            description="Write content to a file (creates or overwrites)",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "path": {
+                        "type": "string",
+                        "description": "Absolute or relative path to the file"
+                    },
+                    "content": {
+                        "type": "string",
+                        "description": "Content to write"
+                    },
+                    "encoding": {
+                        "type": "string",
+                        "description": "File encoding (default: utf-8)",
+                        "default": "utf-8"
+                    }
+                },
+                "required": ["path", "content"]
+            }
+        ),
+        Tool(
+            name="list_directory_tool",
+            description="List contents of a directory",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "path": {
+                        "type": "string",
+                        "description": "Absolute or relative path to the directory"
+                    },
+                    "recursive": {
+                        "type": "boolean",
+                        "description": "If True, list subdirectories recursively",
+                        "default": False
+                    }
+                },
+                "required": ["path"]
+            }
+        ),
+        Tool(
+            name="create_directory_tool",
+            description="Create a new directory (creates parent directories if needed)",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "path": {
+                        "type": "string",
+                        "description": "Absolute or relative path to the directory"
+                    }
+                },
+                "required": ["path"]
+            }
+        ),
+        Tool(
+            name="delete_file_tool",
+            description="Delete a file",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "path": {
+                        "type": "string",
+                        "description": "Absolute or relative path to the file"
+                    }
+                },
+                "required": ["path"]
+            }
+        ),
+        Tool(
+            name="delete_directory_tool",
+            description="Delete a directory",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "path": {
+                        "type": "string",
+                        "description": "Absolute or relative path to the directory"
+                    },
+                    "recursive": {
+                        "type": "boolean",
+                        "description": "If True, delete directory and all contents",
+                        "default": False
+                    }
+                },
+                "required": ["path"]
+            }
+        ),
+        Tool(
+            name="move_file_tool",
+            description="Move or rename a file or directory",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "source": {
+                        "type": "string",
+                        "description": "Source path"
+                    },
+                    "destination": {
+                        "type": "string",
+                        "description": "Destination path"
+                    }
+                },
+                "required": ["source", "destination"]
+            }
+        ),
+        Tool(
+            name="copy_file_tool",
+            description="Copy a file or directory",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "source": {
+                        "type": "string",
+                        "description": "Source path"
+                    },
+                    "destination": {
+                        "type": "string",
+                        "description": "Destination path"
+                    }
+                },
+                "required": ["source", "destination"]
+            }
+        ),
+        Tool(
+            name="search_files_tool",
+            description="Search for files matching a pattern",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "directory": {
+                        "type": "string",
+                        "description": "Directory to search in"
+                    },
+                    "pattern": {
+                        "type": "string",
+                        "description": "Filename pattern (supports wildcards like *.txt)"
+                    },
+                    "recursive": {
+                        "type": "boolean",
+                        "description": "If True, search subdirectories",
+                        "default": True
+                    }
+                },
+                "required": ["directory", "pattern"]
+            }
+        ),
+        Tool(
+            name="get_file_info_tool",
+            description="Get detailed information about a file or directory",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "path": {
+                        "type": "string",
+                        "description": "Absolute or relative path"
+                    }
+                },
+                "required": ["path"]
+            }
+        )
+    ]
+    
+    return ListToolsResult(tools=tools)

pathgate/tools.py

@@ -0,0 +1,457 @@
+from mcp.types import (TextContent, CallToolResult)
+import os
+from pathgate.config import is_path_allowed, server, is_read_only
+import logging
+import json
+import shutil
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+@server.call_tool()
+async def call_tool(name: str, arguments: dict) -> CallToolResult:
+    """Handle tool calls"""
+    try:
+        if name == "read_file_tool":
+            return await read_file_tool(arguments)
+        elif name == "write_file_tool":
+            return await write_file_tool(arguments)
+        elif name == "list_directory_tool":
+            return await list_directory_tool(arguments)
+        elif name == "create_directory_tool":
+            return await create_directory_tool(arguments)
+        elif name == "delete_file_tool":
+            return await delete_file_tool(arguments)
+        elif name == "delete_directory_tool":
+            return await delete_directory_tool(arguments)
+        elif name == "move_file_tool":
+            return await move_file_tool(arguments)
+        elif name == "copy_file_tool":
+            return await copy_file_tool(arguments)
+        elif name == "search_files_tool":
+            return await search_files_tool(arguments)
+        elif name == "get_file_info_tool":
+            return await get_file_info_tool(arguments)
+        else:
+            raise ValueError(f"Unknown tool: {name}")
+    except Exception as e:
+        logger.error(f"Error in {name}: {str(e)}")
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error: {str(e)}")]
+        )
+
+# Tool implementations
+async def read_file_tool(arguments: dict) -> CallToolResult:
+    """Read the contents of a file"""
+    path = arguments["path"]
+    encoding = arguments.get("encoding", "utf-8")
+    
+    if not is_path_allowed(path):
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error: Access denied to {path}")]
+        )
+    
+    if not os.path.exists(path):
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error: File not found: {path}")]
+        )
+    
+    if not os.path.isfile(path):
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error: Not a file: {path}")]
+        )
+    
+    try:
+        with open(path, 'r', encoding=encoding) as f:
+            content = f.read()
+        
+        result = {
+            "path": path,
+            "content": content,
+            "size": len(content),
+            "encoding": encoding
+        }
+        
+        return CallToolResult(
+            content=[TextContent(type="text", text=json.dumps(result, indent=2))]
+        )
+    except UnicodeDecodeError:
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error: Cannot decode file with {encoding} encoding")]
+        )
+    except Exception as e:
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error reading file: {str(e)}")]
+        )
+
+async def write_file_tool(arguments: dict) -> CallToolResult:
+    """Write content to a file"""
+    path = arguments["path"]
+    content = arguments["content"]
+    encoding = arguments.get("encoding", "utf-8")
+
+    iro = is_read_only()
+    if not iro:
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error: Write operations are disabled in read-only mode.")]
+        )
+    
+    if not is_path_allowed(path):
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error: Access denied to {path}")]
+        )
+    
+    try:
+        # Create parent directories if they don't exist
+        os.makedirs(os.path.dirname(os.path.abspath(path)), exist_ok=True)
+        
+        with open(path, 'w', encoding=encoding) as f:
+            f.write(content)
+        
+        result = {
+            "success": True,
+            "path": path,
+            "bytes_written": len(content.encode(encoding))
+        }
+        
+        return CallToolResult(
+            content=[TextContent(type="text", text=json.dumps(result, indent=2))]
+        )
+    except Exception as e:
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error writing file: {str(e)}")]
+        )
+
+async def list_directory_tool(arguments: dict) -> CallToolResult:
+    """List contents of a directory"""
+    path = arguments["path"]
+    recursive = arguments.get("recursive", False)
+    
+    if not is_path_allowed(path):
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error: Access denied to {path}")]
+        )
+    
+    if not os.path.exists(path):
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error: Directory not found: {path}")]
+        )
+    
+    if not os.path.isdir(path):
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error: Not a directory: {path}")]
+        )
+    
+    try:
+        entries = []
+        
+        if recursive:
+            for root, dirs, files in os.walk(path):
+                for name in dirs + files:
+                    item_path = os.path.join(root, name)
+                    stat = os.stat(item_path)
+                    entries.append({
+                        "path": item_path,
+                        "name": name,
+                        "type": "directory" if os.path.isdir(item_path) else "file",
+                        "size": stat.st_size,
+                        "modified": stat.st_mtime
+                    })
+        else:
+            for item in os.listdir(path):
+                item_path = os.path.join(path, item)
+                stat = os.stat(item_path)
+                entries.append({
+                    "path": item_path,
+                    "name": item,
+                    "type": "directory" if os.path.isdir(item_path) else "file",
+                    "size": stat.st_size,
+                    "modified": stat.st_mtime
+                })
+        
+        result = {
+            "path": path,
+            "count": len(entries),
+            "entries": entries
+        }
+        
+        return CallToolResult(
+            content=[TextContent(type="text", text=json.dumps(result, indent=2))]
+        )
+    except Exception as e:
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error listing directory: {str(e)}")]
+        )
+
+async def create_directory_tool(arguments: dict) -> CallToolResult:
+    """Create a new directory"""
+    path = arguments["path"]
+
+    iro = is_read_only()
+    if not iro:
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error: Create operations are disabled in read-only mode.")]
+        )
+    
+    if not is_path_allowed(path):
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error: Access denied to {path}")]
+        )
+    
+    try:
+        os.makedirs(path, exist_ok=True)
+        result = {
+            "success": True,
+            "path": path,
+            "message": "Directory created successfully"
+        }
+        return CallToolResult(
+            content=[TextContent(type="text", text=json.dumps(result, indent=2))]
+        )
+    except Exception as e:
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error creating directory: {str(e)}")]
+        )
+
+async def delete_file_tool(arguments: dict) -> CallToolResult:
+    """Delete a file"""
+    path = arguments["path"]
+
+    iro = is_read_only()
+    if not iro:
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error: Delete operations are disabled in read-only mode.")]
+        )
+    
+    if not is_path_allowed(path):
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error: Access denied to {path}")]
+        )
+    
+    if not os.path.exists(path):
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error: File not found: {path}")]
+        )
+    
+    if not os.path.isfile(path):
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error: Not a file: {path}")]
+        )
+    
+    try:
+        os.remove(path)
+        result = {
+            "success": True,
+            "path": path,
+            "message": "File deleted successfully"
+        }
+        return CallToolResult(
+            content=[TextContent(type="text", text=json.dumps(result, indent=2))]
+        )
+    except Exception as e:
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error deleting file: {str(e)}")]
+        )
+
+async def delete_directory_tool(arguments: dict) -> CallToolResult:
+    """Delete a directory"""
+    path = arguments["path"]
+    recursive = arguments.get("recursive", False)
+
+    iro = is_read_only()
+    if not iro:
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error: Delete operations are disabled in read-only mode.")]
+        )
+    
+    if not is_path_allowed(path):
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error: Access denied to {path}")]
+        )
+    
+    if not os.path.exists(path):
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error: Directory not found: {path}")]
+        )
+    
+    if not os.path.isdir(path):
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error: Not a directory: {path}")]
+        )
+    
+    try:
+        if recursive:
+            shutil.rmtree(path)
+        else:
+            os.rmdir(path)
+        
+        result = {
+            "success": True,
+            "path": path,
+            "message": "Directory deleted successfully"
+        }
+        return CallToolResult(
+            content=[TextContent(type="text", text=json.dumps(result, indent=2))]
+        )
+    except Exception as e:
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error deleting directory: {str(e)}")]
+        )
+
+async def move_file_tool(arguments: dict) -> CallToolResult:
+    """Move or rename a file or directory"""
+    source = arguments["source"]
+    destination = arguments["destination"]
+
+    iro = is_read_only()
+    if not iro:
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error: Move operations are disabled in read-only mode.")]
+        )
+    
+    if not is_path_allowed(source) or not is_path_allowed(destination):
+        return CallToolResult(
+            content=[TextContent(type="text", text="Error: Access denied")]
+        )
+    
+    if not os.path.exists(source):
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error: Source not found: {source}")]
+        )
+    
+    try:
+        shutil.move(source, destination)
+        result = {
+            "success": True,
+            "source": source,
+            "destination": destination,
+            "message": "Moved successfully"
+        }
+        return CallToolResult(
+            content=[TextContent(type="text", text=json.dumps(result, indent=2))]
+        )
+    except Exception as e:
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error moving: {str(e)}")]
+        )
+
+async def copy_file_tool(arguments: dict) -> CallToolResult:
+    """Copy a file or directory"""
+    source = arguments["source"]
+    destination = arguments["destination"]
+
+    iro = is_read_only()
+    if not iro:
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error: Copy operations are disabled in read-only mode.")]
+        )
+    
+    if not is_path_allowed(source) or not is_path_allowed(destination):
+        return CallToolResult(
+            content=[TextContent(type="text", text="Error: Access denied")]
+        )
+    
+    if not os.path.exists(source):
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error: Source not found: {source}")]
+        )
+    
+    try:
+        if os.path.isfile(source):
+            shutil.copy2(source, destination)
+        else:
+            shutil.copytree(source, destination)
+        
+        result = {
+            "success": True,
+            "source": source,
+            "destination": destination,
+            "message": "Copied successfully"
+        }
+        return CallToolResult(
+            content=[TextContent(type="text", text=json.dumps(result, indent=2))]
+        )
+    except Exception as e:
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error copying: {str(e)}")]
+        )
+
+async def search_files_tool(arguments: dict) -> CallToolResult:
+    """Search for files matching a pattern"""
+    directory = arguments["directory"]
+    pattern = arguments["pattern"]
+    recursive = arguments.get("recursive", True)
+    
+    if not is_path_allowed(directory):
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error: Access denied to {directory}")]
+        )
+    
+    if not os.path.exists(directory):
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error: Directory not found: {directory}")]
+        )
+    
+    try:
+        path_obj = Path(directory)
+        if recursive:
+            matches = list(path_obj.rglob(pattern))
+        else:
+            matches = list(path_obj.glob(pattern))
+        
+        results = [str(match) for match in matches]
+        
+        result = {
+            "directory": directory,
+            "pattern": pattern,
+            "count": len(results),
+            "matches": results
+        }
+        
+        return CallToolResult(
+            content=[TextContent(type="text", text=json.dumps(result, indent=2))]
+        )
+    except Exception as e:
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error searching: {str(e)}")]
+        )
+
+async def get_file_info_tool(arguments: dict) -> CallToolResult:
+    """Get detailed information about a file or directory"""
+    path = arguments["path"]
+    
+    if not is_path_allowed(path):
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error: Access denied to {path}")]
+        )
+    
+    if not os.path.exists(path):
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error: Path not found: {path}")]
+        )
+    
+    try:
+        stat = os.stat(path)
+        abs_path = os.path.abspath(path)
+        
+        info = {
+            "path": abs_path,
+            "name": os.path.basename(path),
+            "type": "directory" if os.path.isdir(path) else "file",
+            "size": stat.st_size,
+            "created": stat.st_ctime,
+            "modified": stat.st_mtime,
+            "accessed": stat.st_atime,
+            "permissions": oct(stat.st_mode)[-3:],
+        }
+        
+        if os.path.isfile(path):
+            info["extension"] = os.path.splitext(path)[1]
+        
+        return CallToolResult(
+            content=[TextContent(type="text", text=json.dumps(info, indent=2))]
+        )
+    except Exception as e:
+        return CallToolResult(
+            content=[TextContent(type="text", text=f"Error getting file info: {str(e)}")]
+        )

pathgate-0.1.0.dist-info/METADATA

@@ -0,0 +1,143 @@
+Metadata-Version: 2.5
+Name: pathgate
+Version: 0.1.0
+Summary: Filesystem MCP server with allow-listed directories
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: mcp>=1.25
+Description-Content-Type: text/markdown
+
+# Filesystem MCP Server
+
+`pathgate` is a Python Model Context Protocol (MCP) server that exposes a controlled filesystem interface to MCP clients such as Claude Desktop, Cursor, VS Code, and inspector tools. The server only permits access to directories that are explicitly allow-listed at startup.
+
+## What it does
+
+The server exposes:
+
+- File resources via `file://...`
+- Directory resources via `directory://...`
+- Tools for reading, writing, listing, creating, deleting, moving, copying, searching, and inspecting files/directories
+- Built-in prompts for directory analysis and file discovery
+
+## Security model
+
+Access is restricted by allow-listed paths. At startup, the server resolves the supplied paths and only permits operations within those directories.
+
+- Paths are checked with `os.path.realpath()` and prefix matching
+- Symlinks are resolved before comparison
+- The server can be run in read-only mode to disable mutating operations
+
+## Installation
+
+```bash
+git clone https://github.com/geekgod382/filesystem-mcp-server.git
+cd filesystem-mcp-server
+python -m pip install -e .
+```
+
+This installs the `filesystem-mcp-server` console command from `pyproject.toml`.
+
+## Usage
+
+### Start with allowed directories
+
+```bash
+filesystem-mcp-server "C:\Users\<username>\Documents" "C:\Users\<username>\Projects"
+```
+
+### Read-only mode
+
+```bash
+filesystem-mcp-server --read-only "C:\Users\<username>\Documents"
+```
+
+### Environment variable alternative
+
+```bash
+$env:FS_MCP_ALLOWED_PATHS = "C:\Users\<username>\Documents;C:\Users\<username>\Projects"
+filesystem-mcp-server
+```
+
+On macOS/Linux, use `:` instead of `;` for the path separator.
+
+## Tools
+
+The current implementation exposes these tools:
+
+- `read_file_tool` — read a file and return its content, size, and encoding
+- `write_file_tool` — write content to a file
+- `list_directory_tool` — list directory contents, optionally recursively
+- `create_directory_tool` — create a directory tree if needed
+- `delete_file_tool` — delete a single file
+- `delete_directory_tool` — delete a directory, optionally recursively
+- `move_file_tool` — move or rename a file/directory
+- `copy_file_tool` — copy a file/directory
+- `search_files_tool` — search for files matching a pattern
+- `get_file_info_tool` — return metadata for a file or directory
+
+## MCP client configuration
+
+Example Claude Desktop configuration:
+
+```json
+{
+  "mcpServers": {
+    "filesystem": {
+      "command": "filesystem-mcp-server",
+      "args": ["C:\\Users\\<username>\\Documents"]
+    }
+  }
+}
+```
+
+## Example requests
+
+Once connected, clients can ask:
+
+```text
+List the files in C:\Users\<username>\Documents
+```
+
+```text
+Read C:\Users\<username>\Documents\notes.txt
+```
+
+```text
+Search for *.py files under C:\Users\<username>\Projects
+```
+
+```text
+Create a file at C:\Users\<username>\Documents\todo.txt with the content "Ship release"
+```
+
+## Project layout
+
+```text
+filesystem-mcp-server/
+├── pathgate/
+│   ├── __init__.py
+│   ├── __main__.py
+│   ├── config.py
+│   ├── prompts.py
+│   ├── resources.py
+│   ├── server.py
+│   ├── tool_schemas.py
+│   └── tools.py
+├── tests/
+│   └── test_server.py
+├── pyproject.toml
+├── README.md
+└── LICENSE
+```
+
+## Requirements
+
+- Python 3.10+
+- `mcp>=1.25`
+
+## References
+
+- [Model Context Protocol](https://modelcontextprotocol.io/)
+- [Python SDK](https://github.com/modelcontextprotocol/python-sdk)

pathgate-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+pathgate/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pathgate/__main__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pathgate/config.py,sha256=hfVRr_uCCrDapMlZ21Ckqs-zLAl-VYXZD4PQBL6yslA,1265
+pathgate/prompts.py,sha256=yK4T9VTDoZBmPltjR7hNK8mum8xdg-hOMMJIlkYw0T0,2837
+pathgate/resources.py,sha256=tM3YH3eZpKybXa-AFuXZdj_So8GF7yaRdROyzraLPdY,3370
+pathgate/server.py,sha256=PkwAVBMG4mNm-WMfWS1v1sixef4oZTI6O_dQUTJnMHA,1577
+pathgate/tool_schemas.py,sha256=JJhWI8oih-AzAExBiylK7a7e1UQrp2cjuv-tbeu-mm8,6793
+pathgate/tools.py,sha256=h5xN_hMbrP_xxdzBgBxgOcTGzrl3_g3CsjH8g5BG2eg,15691
+pathgate-0.1.0.dist-info/METADATA,sha256=1d0D_EReHOj3DA5Vy_FCp0dl-VLLMDFimcBDoyOQX1w,3727
+pathgate-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+pathgate-0.1.0.dist-info/entry_points.txt,sha256=rZ5WAyKHrINDn8lmQ-RiwHIUk5xCRVLHs6ei7GturMo,63
+pathgate-0.1.0.dist-info/licenses/LICENSE,sha256=JA1aQy0b0Ni5hczvQz1vwPvpRSDRRMy8RW7RX1rZXuA,1090
+pathgate-0.1.0.dist-info/RECORD,,

pathgate-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pathgate-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+filesystem-mcp-server = pathgate.server:main

pathgate-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Manan Sharma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.