pathgate 0.1.1__tar.gz → 0.2.1__tar.gz

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

@@ -1,14 +1,14 @@
 Metadata-Version: 2.5
 Name: pathgate
-Version: 0.1.1
+Version: 0.2.1
 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 
 
 `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.
 
@@ -31,13 +31,20 @@ Access is restricted by allow-listed paths. At startup, the server resolves the
 
 ## Installation
 
-```bash
-git clone https://github.com/geekgod382/pathgate.git
-cd pathgate
-python -m pip install -e .
+Pathgate package is published on PyPI. To use it, for example with Claude Desktop, add this in the 
+
+```json
+{
+  "mcpServers": {
+    "pathgate": {
+      "command": "uvx",
+      "args": ["pathgate", "C:\\Users\\me\\Documents"]
+    }
+  }
+}
 ```
 
-This installs the `pathgate` console command from `pyproject.toml`.
+This is just an example script
 
 ## Usage
 
@@ -77,20 +84,6 @@ The current implementation exposes these tools:
 - `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": "pathgate",
-      "args": ["C:\\Users\\<username>\\Documents"]
-    }
-  }
-}
-```
 
 ## Example requests
 
@@ -135,7 +128,7 @@ pathgate/
 ## Requirements
 
 - Python 3.10+
-- `mcp>=1.25`
+- `mcp>=2`
 
 ## References
 

{pathgate-0.1.1 → pathgate-0.2.1}/README.md

@@ -1,4 +1,4 @@
-# Pathgate
+# Pathgate 
 
 `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.
 
@@ -21,13 +21,20 @@ Access is restricted by allow-listed paths. At startup, the server resolves the
 
 ## Installation
 
-```bash
-git clone https://github.com/geekgod382/pathgate.git
-cd pathgate
-python -m pip install -e .
+Pathgate package is published on PyPI. To use it, for example with Claude Desktop, add this in the 
+
+```json
+{
+  "mcpServers": {
+    "pathgate": {
+      "command": "uvx",
+      "args": ["pathgate", "C:\\Users\\me\\Documents"]
+    }
+  }
+}
 ```
 
-This installs the `pathgate` console command from `pyproject.toml`.
+This is just an example script
 
 ## Usage
 
@@ -67,20 +74,6 @@ The current implementation exposes these tools:
 - `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": "pathgate",
-      "args": ["C:\\Users\\<username>\\Documents"]
-    }
-  }
-}
-```
 
 ## Example requests
 
@@ -125,7 +118,7 @@ pathgate/
 ## Requirements
 
 - Python 3.10+
-- `mcp>=1.25`
+- `mcp>=2`
 
 ## References
 

pathgate-0.2.1/pathgate/__main__.py

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

{pathgate-0.1.1 → pathgate-0.2.1}/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.2.1/pathgate/install.py

@@ -0,0 +1,254 @@
+"""`pathgate install` - add Pathgate to Claude Desktop's config file.
+
+Usage:
+    uvx pathgate install C:\\Users\\me\\Documents C:\\Users\\me\\Projects
+    uvx pathgate install            (prompts for folders)
+    uvx pathgate install --dry-run ~/Projects
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+import sys
+import tempfile
+from datetime import datetime
+from pathlib import Path
+
+DEFAULT_NAME = "pathgate"
+CONFIG_FILENAME = "claude_desktop_config.json"
+
+
+class InstallError(Exception):
+    """A problem we can explain to the user in one line."""
+
+
+# --------------------------------------------------------------------------
+# Finding the config file
+# --------------------------------------------------------------------------
+
+def claude_desktop_candidates() -> list[Path]:
+    """Every place Claude Desktop might keep its config on this OS."""
+    if sys.platform == "win32":
+        found: list[Path] = []
+        appdata = os.environ.get("APPDATA")
+        if appdata:
+            found.append(Path(appdata) / "Claude" / CONFIG_FILENAME)
+        local = os.environ.get("LOCALAPPDATA")
+        if local:
+            # Microsoft Store (MSIX) installs keep their own private copy.
+            pattern = "Claude_*/LocalCache/Roaming/Claude"
+            for folder in sorted(Path(local, "Packages").glob(pattern)):
+                found.append(folder / CONFIG_FILENAME)
+        return found
+    if sys.platform == "darwin":
+        base = Path.home() / "Library" / "Application Support" / "Claude"
+        return [base / CONFIG_FILENAME]
+    xdg = os.environ.get("XDG_CONFIG_HOME")
+    base = Path(xdg) if xdg else Path.home() / ".config"
+    return [base / "Claude" / CONFIG_FILENAME]
+
+
+def resolve_config_path(explicit: str | None) -> Path:
+    if explicit:
+        return Path(explicit).expanduser().resolve()
+
+    candidates = claude_desktop_candidates()
+    usable = [c for c in candidates if c.exists() or c.parent.exists()]
+    existing = [c for c in usable if c.exists()]
+
+    if len(existing) == 1:
+        return existing[0]
+    if not existing and len(usable) == 1:
+        return usable[0]
+    if not usable:
+        raise InstallError(
+            "couldn't find Claude Desktop's config folder. Is Claude Desktop "
+            "installed? You can point at a config file yourself with --config PATH."
+        )
+    listing = "\n  ".join(str(c) for c in usable)
+    raise InstallError(
+        "found more than one possible Claude Desktop config:\n  "
+        f"{listing}\nRe-run with --config PATH to say which one."
+    )
+
+
+# --------------------------------------------------------------------------
+# Building the entry
+# --------------------------------------------------------------------------
+
+def build_server_entry(paths: list[str], read_only: bool) -> dict:
+    """The `mcpServers` entry that launches Pathgate."""
+    uvx = shutil.which("uvx")
+    uv = shutil.which("uv")
+    if uvx:
+        command, args = uvx, ["pathgate"]
+    elif uv:
+        command, args = uv, ["tool", "run", "pathgate"]
+    else:
+        command, args = sys.executable, ["-m", "pathgate"]
+    args = args + paths
+    if read_only:
+        args.append("--read-only")
+    return {"command": command, "args": args}
+
+
+# --------------------------------------------------------------------------
+# Reading / writing the config safely
+# --------------------------------------------------------------------------
+
+def load_config(path: Path) -> dict:
+    if not path.exists():
+        return {}
+    raw = path.read_text(encoding="utf-8-sig")  # tolerate a BOM
+    if not raw.strip():
+        return {}
+    try:
+        data = json.loads(raw)
+    except json.JSONDecodeError as e:
+        raise InstallError(
+            f"{path} isn't valid JSON ({e}). I haven't changed anything - "
+            "fix the file by hand, then run this again."
+        ) from None
+    if not isinstance(data, dict):
+        raise InstallError(f"{path} doesn't contain a JSON object, so I left it alone.")
+    return data
+
+
+def write_config(path: Path, data: dict) -> Path | None:
+    """Back up the old file, then replace it atomically. Returns the backup path."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    backup = None
+    if path.exists():
+        stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+        backup = path.with_name(f"{path.name}.pathgate-{stamp}.bak")
+        shutil.copy2(path, backup)
+
+    fd, tmp = tempfile.mkstemp(dir=path.parent, prefix=path.name + ".", suffix=".tmp")
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8", newline="\n") as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+            f.write("\n")
+        os.replace(tmp, path)
+    except BaseException:
+        try:
+            os.unlink(tmp)
+        except OSError:
+            pass
+        raise
+    return backup
+
+
+# --------------------------------------------------------------------------
+# The command
+# --------------------------------------------------------------------------
+
+def _prompt_for_paths() -> list[str]:
+    print("Which folders should Pathgate be allowed to access?")
+    print("Enter one folder per line. Press Enter on an empty line when done.")
+    paths: list[str] = []
+    while True:
+        line = input("> ").strip().strip('"').strip("'")
+        if not line:
+            break
+        paths.append(line)
+    return paths
+
+
+def _clean_paths(raw: list[str]) -> list[str]:
+    cleaned: list[str] = []
+    for item in raw:
+        p = Path(item).expanduser().resolve()
+        if not p.is_dir():
+            raise InstallError(f"not a folder: {p}")
+        s = str(p)
+        if s not in cleaned:
+            cleaned.append(s)
+    return cleaned
+
+
+def _confirm(question: str) -> bool:
+    answer = input(f"{question} [Y/n] ").strip().lower()
+    return answer in ("", "y", "yes")
+
+
+def _install(args: argparse.Namespace) -> int:
+    interactive = sys.stdin.isatty()
+
+    raw_paths = list(args.paths)
+    if not raw_paths:
+        if not interactive:
+            raise InstallError(
+                "no folders given. Example: pathgate install C:\\Users\\me\\Documents"
+            )
+        raw_paths = _prompt_for_paths()
+        if not raw_paths:
+            raise InstallError("no folders given, nothing to do.")
+    paths = _clean_paths(raw_paths)
+
+    config_path = resolve_config_path(args.config)
+    data = load_config(config_path)
+    entry = build_server_entry(paths, args.read_only)
+
+    servers = data.setdefault("mcpServers", {})
+    if not isinstance(servers, dict):
+        raise InstallError(f'"mcpServers" in {config_path} isn\'t an object, so I left it alone.')
+
+    existing = servers.get(args.name)
+    if existing == entry:
+        print(f'"{args.name}" is already set up in {config_path}. Nothing to change.')
+        return 0
+
+    print(f"Config file : {config_path}")
+    print(f"Server name : {args.name}")
+    print(f"Command     : {entry['command']} {' '.join(entry['args'])}")
+    print("Folders     : " + ", ".join(paths))
+    print("Mode        : " + ("read-only" if args.read_only else "read/write"))
+    if existing is not None:
+        print(f'Note        : this replaces your current "{args.name}" entry.')
+
+    if args.dry_run:
+        print("\n--dry-run: nothing was written.")
+        return 0
+
+    if not args.yes:
+        if not interactive:
+            raise InstallError("not running in a terminal; pass --yes to proceed.")
+        if not _confirm("\nWrite this to the config?"):
+            print("Cancelled. Nothing was changed.")
+            return 1
+
+    servers[args.name] = entry
+    backup = write_config(config_path, data)
+
+    print(f'\nDone. Added "{args.name}" to {config_path}.')
+    if backup:
+        print(f"Backup of your old config: {backup}")
+    print("Now fully quit Claude Desktop (system tray -> Quit) and reopen it.")
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    p = argparse.ArgumentParser(
+        prog="pathgate install",
+        description="Add Pathgate to Claude Desktop's config file.",
+    )
+    p.add_argument("paths", nargs="*", help="Folders Pathgate may access")
+    p.add_argument("--read-only", action="store_true", help="Disable write/delete/move/copy tools")
+    p.add_argument("--name", default=DEFAULT_NAME, help=f"Entry name in the config (default: {DEFAULT_NAME})")
+    p.add_argument("--config", metavar="PATH", help="Config file to edit (default: auto-detect Claude Desktop)")
+    p.add_argument("--dry-run", action="store_true", help="Show what would change without writing")
+    p.add_argument("-y", "--yes", action="store_true", help="Don't ask for confirmation")
+    args = p.parse_args(argv)
+
+    try:
+        return _install(args)
+    except InstallError as e:
+        print(f"error: {e}", file=sys.stderr)
+        return 1
+    except (KeyboardInterrupt, EOFError):
+        print("\nCancelled. Nothing was changed.", file=sys.stderr)
+        return 130

{pathgate-0.1.1 → pathgate-0.2.1}/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.1/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.2.1/pathgate/server.py

@@ -0,0 +1,75 @@
+import argparse
+import asyncio
+import os
+import sys
+from importlib.metadata import PackageNotFoundError, version
+from pathlib import Path
+
+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",
+        epilog="To add Pathgate to Claude Desktop automatically: pathgate install <folders>",
+    )
+    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 _run():
+    async with stdio_server() as (read_stream, write_stream):
+        await server.run(read_stream, write_stream, server.create_initialization_options())
+
+
+def main():
+    # `pathgate install ...` edits the Claude Desktop config instead of
+    # starting the server. (A folder literally named "install" can still be
+    # passed as ./install.)
+    if sys.argv[1:2] == ["install"]:
+        from pathgate.install import main as install_main
+        raise SystemExit(install_main(sys.argv[2:]))
+
+    paths, read_only = parse_args()
+    configure(paths, read_only)
+    asyncio.run(_run())
+
+
+if __name__ == "__main__":
+    main()

{pathgate-0.1.1 → pathgate-0.2.1}/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.1}/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.1}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pathgate"
-version = "0.1.1"
+version = "0.2.1"
 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")]
-        )

pathgate-0.1.1/pathgate/server.py

@@ -1,42 +0,0 @@
-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="pathgate")
-    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())
-