pathgate 0.1.1__tar.gz → 0.2.0__tar.gz

{pathgate-0.1.1 → pathgate-0.2.0}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.5
 Name: pathgate
-Version: 0.1.1
+Version: 0.2.0
 Summary: Filesystem MCP server with allow-listed directories
 License: MIT
 License-File: LICENSE
 Requires-Python: >=3.10
-Requires-Dist: mcp>=1.25
+Requires-Dist: mcp<3,>=2
 Description-Content-Type: text/markdown
 
 # Pathgate

pathgate-0.2.0/pathgate/__main__.py

@@ -0,0 +1,3 @@
+from pathgate.server import main
+
+main()

{pathgate-0.1.1 → pathgate-0.2.0}/pathgate/config.py

@@ -1,7 +1,6 @@
 from pathlib import Path
 import os
 import logging
-from mcp.server import Server
 
 logging.basicConfig(
     level=logging.INFO,
@@ -10,10 +9,6 @@ logging.basicConfig(
 )
 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}

{pathgate-0.1.1 → pathgate-0.2.0}/pathgate/prompts.py

@@ -1,54 +1,53 @@
-from pathgate.config import server
-from mcp.types import (TextContent, GetPromptResult, ListPromptsResult, PromptMessage, Prompt)
-
-@server.list_prompts()
-async def list_prompts() -> ListPromptsResult:
+from mcp import MCPError
+from mcp.server import ServerRequestContext
+from mcp.types import (INVALID_PARAMS, GetPromptRequestParams, GetPromptResult, ListPromptsResult,
+                       PaginatedRequestParams, Prompt, PromptArgument, PromptMessage, TextContent)
+async def list_prompts(ctx: ServerRequestContext, params: PaginatedRequestParams | None) -> 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
-                }
+                PromptArgument(
+                    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
-                }
+                PromptArgument(
+                    name="directory",
+                    description="Directory to search in",
+                    required=True
+                ),
+                PromptArgument(
+                    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:
+async def get_prompt(ctx: ServerRequestContext, params: GetPromptRequestParams) -> GetPromptResult:
+    name, arguments = params.name, params.arguments or {}
     """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"""
+        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}",

pathgate-0.2.0/pathgate/resources.py

@@ -0,0 +1,55 @@
+import json
+import os
+
+from mcp import MCPError
+from mcp.server import ServerRequestContext
+from mcp.types import (INVALID_PARAMS, ListResourcesResult, PaginatedRequestParams,
+                       ReadResourceRequestParams, ReadResourceResult, Resource,
+                       TextResourceContents)
+
+from pathgate.config import is_path_allowed
+
+
+async def list_resources(ctx: ServerRequestContext, params: PaginatedRequestParams | None) -> ListResourcesResult:
+    return ListResourcesResult(resources=[
+        Resource(uri="file://*", name="File Contents",
+                 description="Read the contents of any file by providing its path",
+                 mime_type="text/plain"),
+        Resource(uri="directory://*", name="Directory Listing",
+                 description="List the contents of any directory by providing its path",
+                 mime_type="application/json"),
+    ])
+
+
+async def read_resource(ctx: ServerRequestContext, params: ReadResourceRequestParams) -> ReadResourceResult:
+    uri = params.uri
+
+    if uri.startswith("file://"):
+        path = uri[len("file://"):]
+        if not is_path_allowed(path):
+            raise MCPError(INVALID_PARAMS, f"Access denied to {path}")
+        if not os.path.isfile(path):
+            raise MCPError(INVALID_PARAMS, f"File not found or not a file: {path}")
+        with open(path, "r", encoding="utf-8") as f:
+            text = f.read()
+        return ReadResourceResult(contents=[
+            TextResourceContents(uri=uri, text=text, mime_type="text/plain")])
+
+    if uri.startswith("directory://"):
+        path = uri[len("directory://"):]
+        if not is_path_allowed(path):
+            raise MCPError(INVALID_PARAMS, f"Access denied to {path}")
+        if not os.path.isdir(path):
+            raise MCPError(INVALID_PARAMS, f"Directory not found: {path}")
+        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=[
+            TextResourceContents(uri=uri, text=json.dumps(entries, indent=2),
+                                 mime_type="application/json")])
+
+    raise MCPError(INVALID_PARAMS, f"Unsupported resource URI: {uri}")

{pathgate-0.1.1 → pathgate-0.2.0}/pathgate/server.py

@@ -1,17 +1,34 @@
-from pathgate.config import configure, server
-from mcp.server.stdio import stdio_server
-from pathgate import tools, resources, prompts, tool_schemas
+import argparse
 import asyncio
 import os
-import argparse
+from importlib.metadata import PackageNotFoundError, version
 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)
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+
+from pathgate import prompts, resources, tool_schemas, tools
+from pathgate.config import configure
+
+
+def _version() -> str:
+    try:
+        return version("pathgate")
+    except PackageNotFoundError:
+        return "0.0.0"
+
+
+server = Server(
+    "pathgate",
+    version=_version(),
+    on_list_tools=tool_schemas.list_tools,
+    on_call_tool=tools.call_tool,
+    on_list_resources=resources.list_resources,
+    on_read_resource=resources.read_resource,
+    on_list_prompts=prompts.list_prompts,
+    on_get_prompt=prompts.get_prompt,
+)
+
 
 def parse_args(argv=None):
     p = argparse.ArgumentParser(prog="pathgate")
@@ -31,12 +48,17 @@ def parse_args(argv=None):
             p.error(f"not a directory: {x}")
     return paths, args.read_only
 
-async def main():
+
+async def _run():
     async with stdio_server() as (read_stream, write_stream):
         await server.run(read_stream, write_stream, server.create_initialization_options())
 
-if __name__ == "__main__":
+
+def main():
     paths, read_only = parse_args()
     configure(paths, read_only)
-    asyncio.run(main())
+    asyncio.run(_run())
+
 
+if __name__ == "__main__":
+    main()

{pathgate-0.1.1 → pathgate-0.2.0}/pathgate/tool_schemas.py

@@ -1,8 +1,7 @@
-from pathgate.config import server
-from mcp.types import Tool, ListToolsResult
+from mcp.server import ServerRequestContext
+from mcp.types import ListToolsResult, PaginatedRequestParams, Tool
 
-@server.list_tools()
-async def list_tools() -> ListToolsResult:
+async def list_tools(ctx: ServerRequestContext, params: PaginatedRequestParams | None) -> ListToolsResult:
     """List available tools"""
     tools = [
         Tool(

{pathgate-0.1.1 → pathgate-0.2.0}/pathgate/tools.py

@@ -1,44 +1,35 @@
-from mcp.types import (TextContent, CallToolResult)
-import os
-from pathgate.config import is_path_allowed, server, is_read_only
+from mcp.server import ServerRequestContext
+from mcp.types import CallToolRequestParams, CallToolResult, TextContent
 import logging
+import os
 import json
+from pathgate.config import is_path_allowed, is_read_only
 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"""
+async def call_tool(ctx: ServerRequestContext, params: CallToolRequestParams) -> CallToolResult:
+    handler = HANDLERS.get(params.name)
+    if handler is None:
+        return _error(f"Unknown tool: {params.name}")
     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}")
+        result = await handler(params.arguments or {})
+    except KeyError as e:
+        return _error(f"Missing required argument: {e.args[0]}")
     except Exception as e:
-        logger.error(f"Error in {name}: {str(e)}")
-        return CallToolResult(
-            content=[TextContent(type="text", text=f"Error: {str(e)}")]
-        )
+        logger.exception("Error in %s", params.name)
+        return _error(str(e))
+
+    # existing handlers return "Error..." text without the error flag
+    text = result.content[0].text if result.content else ""
+    if text.startswith("Error") and not result.is_error:
+        result = result.model_copy(update={"is_error": True})
+    return result
+
+def _error(msg: str) -> CallToolResult:
+    return CallToolResult(content=[TextContent(type="text", text=f"Error: {msg}")], is_error=True)
+
 
 # Tool implementations
 async def read_file_tool(arguments: dict) -> CallToolResult:
@@ -90,8 +81,7 @@ async def write_file_tool(arguments: dict) -> CallToolResult:
     content = arguments["content"]
     encoding = arguments.get("encoding", "utf-8")
 
-    iro = is_read_only()
-    if not iro:
+    if is_read_only():
         return CallToolResult(
             content=[TextContent(type="text", text=f"Error: Write operations are disabled in read-only mode.")]
         )
@@ -187,10 +177,9 @@ async def create_directory_tool(arguments: dict) -> CallToolResult:
     """Create a new directory"""
     path = arguments["path"]
 
-    iro = is_read_only()
-    if not iro:
+    if is_read_only():
         return CallToolResult(
-            content=[TextContent(type="text", text=f"Error: Create operations are disabled in read-only mode.")]
+            content=[TextContent(type="text", text=f"Error: Write operations are disabled in read-only mode.")]
         )
     
     if not is_path_allowed(path):
@@ -217,8 +206,7 @@ async def delete_file_tool(arguments: dict) -> CallToolResult:
     """Delete a file"""
     path = arguments["path"]
 
-    iro = is_read_only()
-    if not iro:
+    if is_read_only():
         return CallToolResult(
             content=[TextContent(type="text", text=f"Error: Delete operations are disabled in read-only mode.")]
         )
@@ -258,8 +246,7 @@ async def delete_directory_tool(arguments: dict) -> CallToolResult:
     path = arguments["path"]
     recursive = arguments.get("recursive", False)
 
-    iro = is_read_only()
-    if not iro:
+    if is_read_only():
         return CallToolResult(
             content=[TextContent(type="text", text=f"Error: Delete operations are disabled in read-only mode.")]
         )
@@ -303,8 +290,7 @@ async def move_file_tool(arguments: dict) -> CallToolResult:
     source = arguments["source"]
     destination = arguments["destination"]
 
-    iro = is_read_only()
-    if not iro:
+    if is_read_only():
         return CallToolResult(
             content=[TextContent(type="text", text=f"Error: Move operations are disabled in read-only mode.")]
         )
@@ -340,8 +326,7 @@ async def copy_file_tool(arguments: dict) -> CallToolResult:
     source = arguments["source"]
     destination = arguments["destination"]
 
-    iro = is_read_only()
-    if not iro:
+    if is_read_only():
         return CallToolResult(
             content=[TextContent(type="text", text=f"Error: Copy operations are disabled in read-only mode.")]
         )
@@ -399,7 +384,7 @@ async def search_files_tool(arguments: dict) -> CallToolResult:
         else:
             matches = list(path_obj.glob(pattern))
         
-        results = [str(match) for match in matches]
+        results = [str(m) for m in matches if is_path_allowed(str(m))]
         
         result = {
             "directory": directory,
@@ -455,3 +440,16 @@ async def get_file_info_tool(arguments: dict) -> CallToolResult:
         return CallToolResult(
             content=[TextContent(type="text", text=f"Error getting file info: {str(e)}")]
         )
+
+HANDLERS = {
+    "read_file_tool": read_file_tool,
+    "write_file_tool": write_file_tool,
+    "list_directory_tool": list_directory_tool,
+    "create_directory_tool": create_directory_tool,
+    "delete_file_tool": delete_file_tool,
+    "delete_directory_tool": delete_directory_tool,
+    "move_file_tool": move_file_tool,
+    "copy_file_tool": copy_file_tool,
+    "search_files_tool": search_files_tool,
+    "get_file_info_tool": get_file_info_tool,
+}

{pathgate-0.1.1 → pathgate-0.2.0}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pathgate"
-version = "0.1.1"
+version = "0.2.0"
 description = "Filesystem MCP server with allow-listed directories"
 readme = "README.md"
 requires-python = ">=3.10"
 license = { text = "MIT" }
-dependencies = ["mcp>=1.25"]
+dependencies = ["mcp>=2,<3"]
 
 [project.scripts]
 pathgate = "pathgate.server:main"

pathgate-0.1.1/pathgate/resources.py

@@ -1,90 +0,0 @@
-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")]
-        )