fs-mcp 1.3.2__py3-none-any.whl

fs_mcp/__main__.py

@@ -0,0 +1,122 @@
+# src/fs_mcp/__main__.py
+
+import argparse
+import sys
+import subprocess
+import time
+from pathlib import Path
+from importlib import metadata
+import toml
+from pyfiglet import Figlet
+
+try:
+    # Use importlib.metadata to find the version of the installed package
+    __version__ = metadata.version("fs-mcp")
+except metadata.PackageNotFoundError:
+    # Fallback for when the package is not installed, e.g., in development
+    try:
+        pyproject_path = Path(__file__).parent.parent.parent / 'pyproject.toml'
+        with open(pyproject_path, 'r') as f:
+            data = toml.load(f)
+            __version__ = data['project']['version']
+    except (ImportError, FileNotFoundError, KeyError):
+        __version__ = "unknown"
+
+def main():
+    f = Figlet(font='slant')
+    banner = f.renderText('fs-mcp')
+    print(banner)
+    print(f"version {__version__}")
+    parser = argparse.ArgumentParser(
+        description="fs-mcp server. By default, runs both UI and HTTP servers.",
+        formatter_class=argparse.RawTextHelpFormatter
+    )
+    # UI flags - now inverted to disable the default
+    ui_group = parser.add_argument_group('UI Options')
+    ui_group.add_argument("--no-ui", action="store_false", dest="run_ui", help="Do not launch the Streamlit Web UI.")
+    ui_group.add_argument("--host", default="0.0.0.0", help="Host for the Streamlit UI.")
+    ui_group.add_argument("--port", default="8123", type=int, help="Port for the Streamlit UI.")
+    
+    # Background HTTP server flags - now inverted
+    http_group = parser.add_argument_group('HTTP Server Options')
+    http_group.add_argument("--no-http", action="store_false", dest="run_http", help="Do not run a background HTTP MCP server.")
+    http_group.add_argument("--http-host", default="0.0.0.0", help="Host for the background HTTP server.")
+    http_group.add_argument("--http-port", type=int, default=8124, help="Port for the background HTTP server.")
+
+    # Common args
+    parser.add_argument("dirs", nargs="*", help="Allowed directories (applies to all server modes).")
+    
+    args, unknown = parser.parse_known_args()
+    dirs = args.dirs or [str(Path.cwd())]
+
+    http_process = None
+    try:
+        # --- Start Background HTTP Server if requested ---
+        if args.run_http:
+            # Command to run our dedicated HTTP runner script
+            http_cmd = [
+                sys.executable, "-m", "fs_mcp.http_runner",
+                "--host", args.http_host,
+                "--port", str(args.http_port),
+                *dirs
+            ]
+            print(f"🚀 Launching background HTTP MCP server process on http://{args.http_host}:{args.http_port}", file=sys.stderr)
+            
+            # Use Popen to start the process without blocking.
+            # We pipe stdout/stderr so they don't clutter the main console unless there's an error.
+            http_process = subprocess.Popen(http_cmd, stdout=sys.stderr, stderr=sys.stderr)
+            
+            # Give it a moment to start up and check for instant failure.
+            time.sleep(2) 
+            if http_process.poll() is not None:
+                print("❌ Background HTTP server failed to start. Check logs.", file=sys.stderr)
+                sys.exit(1)
+
+        # --- Start Foreground Application (UI or wait) ---
+        if args.run_ui:
+            current_dir = Path(__file__).parent
+            ui_path = (current_dir / "web_ui.py").resolve()
+            if not ui_path.exists():
+                raise FileNotFoundError(f"Could not find web_ui.py at {ui_path}")
+            
+            ui_cmd = [
+                sys.executable, "-m", "streamlit", "run", str(ui_path),
+                "--server.address", args.host,
+                "--server.port", str(args.port),
+                "--", *[str(Path(d).resolve()) for d in dirs]
+            ]
+            print(f"🚀 Launching UI on http://{args.host}:{args.port}", file=sys.stderr)
+            # This is a blocking call. The script waits here until Streamlit exits.
+            subprocess.run(ui_cmd)
+
+        elif args.run_http and http_process:
+            # If ONLY the http server is running, we just need to wait.
+            print("Background HTTP server is running. Press Ctrl+C to stop.", file=sys.stderr)
+            http_process.wait()
+            
+        if not args.run_ui and not args.run_http:
+            # Default: run the original stdio server. This should be a direct import.
+            from fs_mcp import server
+            print("🚀 Launching Stdio MCP server", file=sys.stderr)
+            server.initialize(dirs)
+            server.mcp.run()
+
+    except KeyboardInterrupt:
+        print("\nCaught interrupt, shutting down...", file=sys.stderr)
+    
+    finally:
+        # This block is GUARANTEED to run, ensuring the background process is cleaned up.
+        if http_process:
+            print("Terminating background HTTP server...", file=sys.stderr)
+            http_process.terminate()  # Sends SIGTERM for a graceful shutdown
+            try:
+                # Wait up to 5 seconds for it to shut down
+                http_process.wait(timeout=5)
+                print("Background server stopped gracefully.", file=sys.stderr)
+            except subprocess.TimeoutExpired:
+                # If it's stuck, force kill it.
+                print("Server did not terminate gracefully, killing.", file=sys.stderr)
+                http_process.kill()
+
+if __name__ == "__main__":
+    main()

fs_mcp/http_runner.py

@@ -0,0 +1,28 @@
+import argparse
+from fs_mcp import server
+
+def main():
+    """
+    This is a dedicated entry point for running the FastMCP server in HTTP mode.
+    It's designed to be called as a subprocess from the main CLI.
+    """
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--host", required=True)
+    parser.add_argument("--port", type=int, required=True)
+    parser.add_argument("dirs", nargs="*")
+    args = parser.parse_args()
+    
+    try:
+        server.initialize(args.dirs)
+        server.mcp.run(
+            transport="streamable-http",
+            host=args.host,
+            port=args.port
+        )
+    except KeyboardInterrupt:
+        pass # The main process will handle termination.
+    except Exception as e:
+        print(f"HTTP runner failed: {e}")
+
+if __name__ == "__main__":
+    main()

fs_mcp/server.py

@@ -0,0 +1,495 @@
+import json
+from pydantic import BaseModel
+from typing import Optional
+
+class FileReadRequest(BaseModel):
+    path: str
+    head: Optional[int] = None
+    tail: Optional[int] = None
+
+
+import os
+import base64
+import mimetypes
+import fnmatch
+from pathlib import Path
+from typing import List, Optional, Literal, Dict
+from datetime import datetime
+from fastmcp import FastMCP
+import tempfile
+import time
+import shutil
+import subprocess
+
+from dataclasses import dataclass
+import difflib
+
+# The new structure for returning detailed results from the edit tool.
+@dataclass
+class EditResult:
+    success: bool
+    message: str
+    diff: Optional[str] = None
+    error_type: Optional[str] = None
+    original_content: Optional[str] = None
+    new_content: Optional[str] = None
+
+
+# --- Global Configuration ---
+USER_ACCESSIBLE_DIRS: List[Path] = []
+ALLOWED_DIRS: List[Path] = []
+mcp = FastMCP("filesystem")
+IS_VSCODE_CLI_AVAILABLE = False
+
+
+def initialize(directories: List[str]):
+    """Initialize the allowed directories and check for VS Code CLI."""
+    global ALLOWED_DIRS, USER_ACCESSIBLE_DIRS, IS_VSCODE_CLI_AVAILABLE
+    ALLOWED_DIRS.clear()
+    USER_ACCESSIBLE_DIRS.clear()
+    
+    IS_VSCODE_CLI_AVAILABLE = shutil.which('code') is not None
+
+    raw_dirs = directories or [str(Path.cwd())]
+    
+    # Process user-specified directories
+    for d in raw_dirs:
+        try:
+            p = Path(d).expanduser().resolve()
+            if not p.exists() or not p.is_dir():
+                print(f"Warning: Skipping invalid directory: {p}")
+                continue
+            USER_ACCESSIBLE_DIRS.append(p)
+        except Exception as e:
+            print(f"Warning: Could not resolve {d}: {e}")
+
+    # The full list of allowed directories includes the user-accessible ones
+    # and the system's temporary directory for internal review sessions.
+    ALLOWED_DIRS.extend(USER_ACCESSIBLE_DIRS)
+    ALLOWED_DIRS.append(Path(tempfile.gettempdir()).resolve())
+
+    if not USER_ACCESSIBLE_DIRS:
+        print("Warning: No valid user directories. Defaulting to CWD.")
+        cwd = Path.cwd()
+        USER_ACCESSIBLE_DIRS.append(cwd)
+        if cwd not in ALLOWED_DIRS:
+            ALLOWED_DIRS.append(cwd)
+            
+    return USER_ACCESSIBLE_DIRS
+
+def validate_path(requested_path: str) -> Path:
+    """
+    Security barrier: Ensures path is within ALLOWED_DIRS.
+    Handles both absolute and relative paths. Relative paths are resolved 
+    against the first directory in ALLOWED_DIRS.
+    """
+    
+    # an 'empty' path should always resolve to the primary allowed directory
+    if not requested_path or requested_path == ".":
+        return ALLOWED_DIRS[0]
+
+    
+    p = Path(requested_path).expanduser()
+    
+    # If the path is relative, resolve it against the primary allowed directory.
+    if not p.is_absolute():
+        # Ensure the base directory for relative paths is always the first one.
+        base_dir = ALLOWED_DIRS[0]
+        p = base_dir / p
+
+    # --- Security Check: Resolve the final path and verify it's within bounds ---
+    try:
+        # .resolve() is crucial for security as it canonicalizes the path,
+        # removing any ".." components and resolving symlinks.
+        path_obj = p.resolve()
+    except Exception:
+        # Fallback for paths that might not exist yet but are being created.
+        path_obj = p.absolute()
+
+    is_allowed = any(
+        str(path_obj).startswith(str(allowed)) 
+        for allowed in ALLOWED_DIRS
+    )
+
+    # If the path is in the temp directory, apply extra security checks.
+    temp_dir = Path(tempfile.gettempdir()).resolve()
+    if is_allowed and str(path_obj).startswith(str(temp_dir)):
+        # Allow access to the temp directory itself, but apply stricter checks for its contents.
+        if path_obj != temp_dir:
+            path_str = str(path_obj)
+            is_review_dir = "mcp_review_" in path_str
+            is_pytest_dir = "pytest-" in path_str
+
+            if not (is_review_dir or is_pytest_dir):
+                is_allowed = False
+            # For review directories, apply stricter checks.
+            elif is_review_dir and not (path_obj.name.startswith("current_") or path_obj.name.startswith("future_")):
+                is_allowed = False
+            
+    if not is_allowed:
+        raise ValueError(f"Access denied: {requested_path} is outside allowed directories: {ALLOWED_DIRS}")
+        
+    return path_obj
+
+def format_size(size_bytes: float) -> str:
+    for unit in ['B', 'KB', 'MB', 'GB', 'TB']:
+        if size_bytes < 1024.0:
+            return f"{size_bytes:.2f} {unit}"
+        size_bytes /= 1024.0
+    return f"{size_bytes:.2f} PB"
+
+# --- Tools ---
+
+@mcp.tool()
+def list_allowed_directories() -> str:
+    """List the directories this server is allowed to access."""
+    return "\n".join(str(d) for d in USER_ACCESSIBLE_DIRS)
+
+@mcp.tool()
+def read_files(files: List[FileReadRequest]) -> str:
+    """
+    Read the contents of multiple files simultaneously.
+    Returns path and content separated by dashes.
+    Prefer relative paths.
+    """
+    results = []
+    for file_request_data in files:
+        if isinstance(file_request_data, dict):
+            file_request = FileReadRequest(**file_request_data)
+        else:
+            file_request = file_request_data
+            
+        try:
+            path_obj = validate_path(file_request.path)
+            if file_request.head is not None and file_request.tail is not None:
+                raise ValueError("Cannot specify both head and tail for a single file.")
+            
+            if path_obj.is_dir():
+                content = "Error: Is a directory"
+            else:
+                try:
+                    with open(path_obj, 'r', encoding='utf-8') as f:
+                        if file_request.head is not None:
+                            content = "".join([next(f) for _ in range(file_request.head)])
+                        elif file_request.tail is not None:
+                            content = "".join(f.readlines()[-file_request.tail:])
+                        else:
+                            content = f.read()
+                except UnicodeDecodeError:
+                    content = "Error: Binary file. Use read_media_file."
+            
+            results.append(f"File: {file_request.path}\n{content}")
+        except Exception as e:
+            results.append(f"File: {file_request.path}\nError: {e}")
+            
+    return "\n\n---\n\n".join(results)
+
+@mcp.tool()
+def read_media_file(path: str) -> dict:
+    """Read an image or audio file as base64. Prefer relative paths."""
+    path_obj = validate_path(path)
+    mime_type, _ = mimetypes.guess_type(path_obj)
+    if not mime_type: mime_type = "application/octet-stream"
+        
+    try:
+        with open(path_obj, "rb") as f:
+            data = base64.b64encode(f.read()).decode("utf-8")
+        
+        type_category = "image" if mime_type.startswith("image/") else "audio" if mime_type.startswith("audio/") else "blob"
+        return {"type": type_category, "data": data, "mimeType": mime_type}
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+def write_file(path: str, content: str) -> str:
+    """Create a new file or completely overwrite an existing file. Prefer relative paths."""
+    path_obj = validate_path(path)
+    with open(path_obj, 'w', encoding='utf-8') as f:
+        f.write(content)
+    return f"Successfully wrote to {path}"
+
+@mcp.tool()
+def create_directory(path: str) -> str:
+    """Create a new directory or ensure it exists. Prefer relative paths."""
+    path_obj = validate_path(path)
+    os.makedirs(path_obj, exist_ok=True)
+    return f"Successfully created directory {path}"
+
+@mcp.tool()
+def list_directory(path: str) -> str:
+    """Get a detailed listing of all files and directories. Prefer relative paths."""
+    path_obj = validate_path(path)
+    if not path_obj.is_dir(): return f"Error: {path} is not a directory"
+    
+    entries = []
+    for entry in path_obj.iterdir():
+        prefix = "[DIR]" if entry.is_dir() else "[FILE]"
+        entries.append(f"{prefix} {entry.name}")
+    return "\n".join(sorted(entries))
+
+@mcp.tool()
+def list_directory_with_sizes(path: str) -> str:
+    """Get listing with file sizes. Prefer relative paths."""
+    path_obj = validate_path(path)
+    if not path_obj.is_dir(): return f"Error: Not a directory"
+    
+    output = []
+    for entry in path_obj.iterdir():
+        try:
+            s = entry.stat().st_size if not entry.is_dir() else 0
+            prefix = "[DIR]" if entry.is_dir() else "[FILE]"
+            size_str = "" if entry.is_dir() else format_size(s)
+            output.append(f"{prefix} {entry.name.ljust(30)} {size_str}")
+        except: continue
+    return "\n".join(sorted(output))
+
+@mcp.tool()
+def move_file(source: str, destination: str) -> str:
+    """Move or rename files. Prefer relative paths."""
+    src = validate_path(source)
+    dst = validate_path(destination)
+    if dst.exists(): raise ValueError(f"Destination {destination} already exists")
+    src.rename(dst)
+    return f"Moved {source} to {destination}"
+
+@mcp.tool()
+def search_files(path: str, pattern: str) -> str:
+    """Recursively search for files matching a glob pattern. Prefer relative paths."""
+    root = validate_path(path)
+    try:
+        results = [str(p.relative_to(root)) for p in root.rglob(pattern) if p.is_file()]
+        return "\n".join(results) or "No matches found."
+    except Exception as e:
+        return f"Error during search: {e}"
+
+
+@mcp.tool()
+def get_file_info(path: str) -> str:
+    """Retrieve detailed metadata. Prefer relative paths."""
+    p = validate_path(path)
+    s = p.stat()
+    return f"Path: {p}\nType: {'Dir' if p.is_dir() else 'File'}\nSize: {format_size(s.st_size)}\nModified: {datetime.fromtimestamp(s.st_mtime)}"
+
+@mcp.tool()
+def directory_tree(path: str, max_depth: int = 4, exclude_dirs: Optional[List[str]] = None) -> str:
+    """Get recursive JSON tree with depth limit and default excludes."""
+    root = validate_path(path)
+    
+    # Use provided excludes or our new smart defaults
+    default_excludes = ['.git', '.venv', '__pycache__', 'node_modules', '.pytest_cache']
+    excluded = exclude_dirs if exclude_dirs is not None else default_excludes
+    max_depth = 3 if isinstance(max_depth,str) else max_depth
+
+    def build(current: Path, depth: int) -> Optional[Dict]:
+        if depth > max_depth or current.name in excluded:
+            return None
+        
+        node: Dict[str, object] = {"name": current.name, "type": "directory" if current.is_dir() else "file"}
+        
+        if current.is_dir():
+            children: List[Dict] = []
+            try:
+                for entry in sorted(current.iterdir(), key=lambda x: x.name):
+                    child = build(entry, depth + 1)
+                    if child:
+                        children.append(child)
+                if children:
+                    node["children"] = children
+            except PermissionError:
+                node["error"] = "Permission Denied"
+        return node
+        
+    tree = build(root, 0)
+    return json.dumps(tree, indent=2)
+
+class RooStyleEditTool:
+    """A robust, agent-friendly file editing tool."""
+    def count_occurrences(self, content: str, substr: str) -> int:
+        return content.count(substr) if substr else 0
+    def normalize_line_endings(self, content: str) -> str:
+        return content.replace('\r\n', '\n').replace('\r', '\n')
+    
+    def _prepare_edit(self, file_path: str, old_string: str, new_string: str, expected_replacements: int) -> EditResult:
+        p = validate_path(file_path)
+        file_exists = p.exists()
+        is_new_file = not file_exists and old_string == ""
+        if not file_exists and not is_new_file:
+            return EditResult(success=False, message=f"File not found: {file_path}", error_type="file_not_found")
+        if file_exists and is_new_file:
+            return EditResult(success=False, message=f"File '{file_path}' already exists.", error_type="file_exists")
+        original_content = p.read_text(encoding='utf-8') if file_exists else ""
+        normalized_content = self.normalize_line_endings(original_content)
+        normalized_old = self.normalize_line_endings(old_string)
+        if not is_new_file:
+            if old_string == new_string:
+                return EditResult(success=False, message="No changes to apply.", error_type="validation_error")
+            occurrences = self.count_occurrences(normalized_content, normalized_old)
+            if occurrences == 0:
+                return EditResult(success=False, message="No match found for 'old_string'.", error_type="validation_error")
+            if occurrences != expected_replacements:
+                return EditResult(success=False, message=f"Expected {expected_replacements} occurrences but found {occurrences}.", error_type="validation_error")
+        new_content = new_string if is_new_file else normalized_content.replace(normalized_old, new_string)
+        return EditResult(success=True, message="Edit prepared.", original_content=original_content, new_content=new_content)
+
+# --- Interactive Human-in-the-Loop Tools ---
+APPROVAL_KEYWORD = "##APPROVE##"
+
+
+
+
+@mcp.tool()
+def propose_and_review(path: str, new_string: str, old_string: str = "", expected_replacements: int = 1, session_path: Optional[str] = None) -> str:
+    """
+    Starts or continues an interactive review session using a VS Code diff view. This smart tool adapts its behavior based on the arguments provided.
+
+    Intents:
+
+    1.  **Start New Review (Patch):** Provide `path`, `old_string`, `new_string`. Validates the patch against the original file.
+    2.  **Start New Review (Full Rewrite):** Provide `path`, `new_string`, and leave `old_string` empty.
+    3.  **Continue Review (Contextual Patch):** Provide `path`, `session_path`, `old_string`, and `new_string`.
+        *   **CRITICAL:** If the user modified the file in the previous turn (indicated by `user_feedback_diff`), `old_string` MUST match the text **as modified by the user**, not your previous `new_string`. You must apply the user's diff to your previous output to determine the correct `old_string` for this step.
+    4.  **Continue Review (Full Rewrite / Recovery):** Provide `path`, `session_path`, `new_string`, and the full content of the file as `old_string`.
+
+    Note: `path` is always required to identify the file being edited, even when continuing a session.
+
+    It blocks and waits for the user to save the file, then returns their action ('APPROVE' or 'REVIEW').
+    """
+    tool = RooStyleEditTool()
+    original_path_obj = Path(path)
+    active_proposal_content = ""
+
+    # --- Step 1: Determine Intent and Prepare Session ---
+    if session_path:
+        # --- INTENT: CONTINUING AN EXISTING SESSION ---
+        temp_dir = Path(session_path)
+        if not temp_dir.is_dir():
+            raise ValueError(f"Session path {session_path} does not exist.")
+        
+        current_file_path = temp_dir / f"current_{original_path_obj.name}"
+        future_file_path = temp_dir / f"future_{original_path_obj.name}"
+        
+        staged_content = current_file_path.read_text(encoding='utf-8')
+        
+        # The `old_string` is the "contextual anchor". We try to apply it as a patch.
+        occurrences = tool.count_occurrences(staged_content, old_string)
+        
+        if occurrences != 1:
+            # SAFETY VALVE: The patch is ambiguous or invalid. Fail gracefully.
+            raise ValueError(f"Contextual patch failed. The provided 'old_string' anchor was found {occurrences} times in the user's last version, but expected exactly 1. Please provide the full file content as 'old_string' to recover.")
+            
+        # Patch successfully applied.
+        active_proposal_content = staged_content.replace(old_string, new_string, 1)
+        future_file_path.write_text(active_proposal_content, encoding='utf-8')
+
+    else:
+        # --- INTENT: STARTING A NEW SESSION ---
+        temp_dir = Path(tempfile.mkdtemp(prefix="mcp_review_"))
+        current_file_path = temp_dir / f"current_{original_path_obj.name}"
+        future_file_path = temp_dir / f"future_{original_path_obj.name}"
+        
+        prep_result = tool._prepare_edit(path, old_string, new_string, expected_replacements)
+        if not prep_result.success:
+            if temp_dir.exists(): shutil.rmtree(temp_dir)
+            raise ValueError(f"Edit preparation failed: {prep_result.message} (Error type: {prep_result.error_type})")
+
+        if prep_result.original_content is not None:
+            current_file_path.write_text(prep_result.original_content, encoding='utf-8')
+        active_proposal_content = prep_result.new_content
+        if active_proposal_content is not None:
+            future_file_path.write_text(active_proposal_content, encoding='utf-8')
+
+    # --- Step 2: Display, Launch, and Wait for Human ---
+    vscode_command = f'code --diff "{current_file_path}" "{future_file_path}"'
+    
+    print(f"\n--- WAITING FOR HUMAN REVIEW ---\nPlease review the proposed changes in VS Code:\n\n{vscode_command}\n")
+    print(f'To approve, add a double newline to the end of the file before saving.')
+    if IS_VSCODE_CLI_AVAILABLE:
+        try:
+            subprocess.Popen(vscode_command, shell=True)
+            print("✅ Automatically launched VS Code diff view.")
+        except Exception as e:
+            print(f"⚠️ Failed to launch VS Code automatically: {e}")
+
+    initial_mod_time = future_file_path.stat().st_mtime
+    while True:
+        time.sleep(1)
+        if future_file_path.stat().st_mtime > initial_mod_time: break
+    
+    # --- Step 3: Interpret User's Action ---
+    user_edited_content = future_file_path.read_text(encoding='utf-8')
+    response = {"session_path": str(temp_dir)}
+
+    if user_edited_content.endswith("\n\n"):
+        # Remove trailing newlines
+        clean_content = user_edited_content.rstrip('\n')
+        # hey roo confirm if this triggers ONLY IF the user manually appends 2 newline in their review. otherwise we'll have false positive. 
+        try:
+            future_file_path.write_text(clean_content, encoding='utf-8')
+            print("✅ Approval detected. You can safely close the diff view.")
+        except Exception as e:
+            print(f"⚠️ Could not auto-remove keyword from review file: {e}")
+        response["user_action"] = "APPROVE"
+        response["message"] = "User has approved the changes. Call 'commit_review' to finalize."
+    else:
+        current_file_path.write_text(user_edited_content, encoding='utf-8')
+        user_feedback_diff = "".join(difflib.unified_diff(
+            active_proposal_content.splitlines(keepends=True) if active_proposal_content is not None else [],
+            user_edited_content.splitlines(keepends=True),
+            fromfile=f"a/{future_file_path.name} (agent proposal)",
+            tofile=f"b/{future_file_path.name} (user feedback)"
+        ))
+        response["user_action"] = "REVIEW"
+        response["message"] = "User provided feedback. A diff is included. Propose a new edit against the updated content."
+        response["user_feedback_diff"] = user_feedback_diff
+        
+    return json.dumps(response, indent=2)
+
+@mcp.tool()
+def commit_review(session_path: str, original_path: str) -> str:
+    """Finalizes an interactive review session by committing the approved changes."""
+    session_dir = Path(session_path)
+    original_file = validate_path(original_path)
+    if not session_dir.is_dir():
+        raise ValueError(f"Invalid session path: {session_path}")
+    future_file = session_dir / f"future_{original_file.name}"
+    if not future_file.exists():
+        raise FileNotFoundError(f"Approved file not found in session: {future_file}")
+    approved_content = future_file.read_text(encoding='utf-8')
+    final_content = approved_content.rstrip('\n')
+    try:
+        original_file.write_text(final_content, encoding='utf-8')
+    except Exception as e:
+        raise IOError(f"Failed to write final content to {original_path}: {e}")
+    try:
+        shutil.rmtree(session_dir)
+    except Exception as e:
+        return f"Successfully committed changes to {original_path}, but failed to clean up session dir {session_path}: {e}"
+    return f"Successfully committed changes to '{original_path}' and cleaned up the review session."
+@mcp.tool()
+def grounding_search(query: str) -> str:
+    """[NEW] A custom search tool. Accepts a natural language query and returns a grounded response."""
+    # This is a placeholder for a future RAG or other search implementation.
+    print(f"Received grounding search query: {query}")
+    return "DEVELOPER PLEASE UPDATE THIS WITH ACTUAL CONTENT"
+
+
+@mcp.tool()
+def append_text(path: str, content: str) -> str:
+    """
+    Append text to the end of a file. 
+    Use this as a fallback if edit_file fails to find a match.
+    Prefer relative paths.
+    """
+    p = validate_path(path)
+    if not p.exists():
+        raise FileNotFoundError(f"File not found: {path}. Cannot append to a non-existent file.")
+    
+    # Ensure there is a newline at the start of the append if the file doesn't have one
+    # to avoid clashing with the existing last line.
+    with open(p, 'a', encoding='utf-8') as f:
+        # Check if we need a leading newline
+        if p.stat().st_size > 0:
+            f.write("\n")
+        f.write(content)
+        
+    return f"Successfully appended content to '{path}'."

fs_mcp/web_ui.py

@@ -0,0 +1,395 @@
+import streamlit as st
+import sys
+import inspect
+import json
+import base64
+import asyncio
+import copy
+from typing import Optional, Union, List, Dict, Any
+from pathlib import Path
+from dataclasses import asdict
+from fastmcp.utilities.inspect import inspect_fastmcp
+from streamlit_js_eval import streamlit_js_eval
+
+# --- 1. SETUP & CONFIG ---
+st.set_page_config(page_title="FS-MCP", layout="wide", page_icon="📂")
+
+import tempfile
+
+def get_workspace_description():
+    """
+    Calls list_allowed_directories and list_directory to generate
+    a descriptive text of the workspace, excluding temporary directories.
+    """
+    try:
+        # 1. Get allowed directories
+        list_dirs_fn = tools.get('list_allowed_directories')
+        list_dir_fn = tools.get('list_directory')
+        directory_tree_fn = tools.get('directory_tree')
+
+        if not list_dirs_fn or not list_dir_fn or not directory_tree_fn:
+            return "Error: Core directory tools not found."
+
+        allowed_dirs_str = list_dirs_fn()
+        
+        # Filter out the temporary directory
+        temp_dir = tempfile.gettempdir()
+        allowed_dirs = [
+            d.strip() for d in allowed_dirs_str.split('\n') 
+            if d.strip() and not d.strip().startswith(temp_dir)
+        ]
+        
+        # Reconstruct the string for display, excluding the temp dir
+        filtered_dirs_str = "\n".join(allowed_dirs)
+
+        dir_tree_listings = []
+        for d in allowed_dirs:
+            tree = directory_tree_fn(path=d)
+            dir_tree_listings.append(f"Directory: {d}\n---\n{tree}\n")
+        dir_tree_str = "\n".join(dir_tree_listings)
+
+        # 2. Get directory listings for each allowed directory
+        dir_listings = []
+        for d in allowed_dirs:
+            listing = list_dir_fn(path=d)
+            dir_listings.append(f"Directory: {d}\n---\n{listing}\n")
+        
+        # 3. Format the final output
+        full_listing_str = "\n".join(dir_listings)
+        output = (
+            "\n```\n"
+            "This is the initial result for MCP calls :\n\n"
+            "== list_allowed_directories ==\n"
+            f"{filtered_dirs_str}\n\n"
+            "== list_directory ==\n"
+            f"{full_listing_str}\n\n"
+            "== directory_tree ==\n"
+            f"{dir_tree_str}"
+            "\n```\n"
+        )
+        return output
+
+    except Exception as e:
+        return f"Error generating room description: {e}"
+
+
+# [NEW] Import Google GenAI transformers for schema standardization
+try:
+    from google.genai import _transformers
+except ImportError:
+    st.error("❌ 'google-genai' library not found. Please run: uv add google-genai")
+    st.stop()
+
+try:
+    from fs_mcp import server
+except ImportError:
+    st.error("❌ Could not import 'fs_mcp.server'. Is the package installed?")
+    st.stop()
+
+# Initialize Config from CLI Args
+try:
+    if "--" in sys.argv:
+        raw_args = sys.argv[sys.argv.index("--") + 1:]
+    else:
+        raw_args = [a for a in sys.argv[1:] if not a.startswith("-")]
+    server.initialize(raw_args)
+except Exception as e:
+    st.error(f"❌ Configuration Error: {e}")
+    st.stop()
+
+# --- 2. HEADER ---
+st.title("📂 FS-MCP Explorer")
+if not server.ALLOWED_DIRS:
+    st.warning("⚠️ No directories configured! Defaulting to CWD.")
+
+st.sidebar.header("Active Configuration")
+st.sidebar.code("\n".join(str(d) for d in server.ALLOWED_DIRS))
+
+
+# --- 3. TOOL DISCOVERY & SCHEMA EXPORT ---
+tools = {}
+tool_schemas = []
+gemini_schemas = []
+
+def prune_for_gemini_strictness(obj: Any) -> Any:
+    """
+    Recursively removes keys that are valid in JSON Schema/OpenAPI 
+    but strictly forbidden by the Gemini Function Calling API.
+    """
+    # Keys forbidden by Gemini's strict validator
+    FORBIDDEN_KEYS = {"default", "title", "property_ordering", "propertyOrdering"}
+
+    if isinstance(obj, dict):
+        return {
+            k: prune_for_gemini_strictness(v) 
+            for k, v in obj.items() 
+            if k not in FORBIDDEN_KEYS
+        }
+    elif isinstance(obj, list):
+        return [prune_for_gemini_strictness(i) for i in obj]
+    return obj
+
+def convert_to_gemini_schema(tool_dict: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Uses official google-genai transformers + strict pruning to adapt 
+    schemas for Gemini Function Declarations.
+    """
+    # 1. Deep copy the input schema
+    raw_schema = copy.deepcopy(tool_dict.get("input_schema", {}))
+    
+    # 2. Use the official library transformer to handle anyOf -> nullable
+    # This handles the complex logic.
+    _transformers.process_schema(raw_schema, client=None)
+    
+    # 3. [NEW] Strict Pruning
+    # Gemini rejects "default", "title", and "property_ordering"
+    clean_schema = prune_for_gemini_strictness(raw_schema)
+    
+    # 4. Ensure root type is object
+    if "type" not in clean_schema:
+        clean_schema["type"] = "object"
+    if "properties" not in clean_schema:
+        clean_schema["properties"] = {}
+
+    return {
+        "name": tool_dict["name"],
+        "description": tool_dict.get("description", ""),
+        "parameters": clean_schema
+    }
+
+
+try:
+    # 1. Use the official inspect utility to get a structured server blueprint
+    server_info = asyncio.run(inspect_fastmcp(server.mcp))
+
+    # 2. Convert the ToolInfo dataclasses to dictionaries
+    tool_schemas = [asdict(tool) for tool in server_info.tools]
+
+    # 3. [NEW] Generate Gemini-compatible schemas using the official library
+    gemini_schemas = [convert_to_gemini_schema(ts) for ts in tool_schemas]
+
+    # 4. Map the functions for the UI to execute
+    for tool_info in server_info.tools:
+        name = tool_info.name
+        if hasattr(server, name):
+            wrapper = getattr(server, name)
+            # Unwrap FastMCP decorators if needed
+            fn = wrapper.fn if hasattr(wrapper, 'fn') else wrapper
+            tools[name] = fn
+        else:
+            st.warning(f"Tool '{name}' has a schema but no matching function found in server.py")
+
+except Exception as e:
+    st.error(f"Failed to inspect MCP server: {e}")
+    st.exception(e) 
+    st.stop()
+
+# --- 3.5. ROOM DESCRIPTION ---
+if 'workspace_description' not in st.session_state:
+    st.session_state.workspace_description = get_workspace_description()
+
+with st.sidebar.expander("📝 Workspace Description", expanded=False):
+    st.caption("Copy this to quickly onboard the agent")
+    st.code(st.session_state.workspace_description, language="md")
+
+# --- SIDEBAR: EXPORT SECTION ---
+with st.sidebar.expander("🔌 Gemini API Schemas", expanded=False):
+    st.caption("Copy this JSON for Gemini Function Declarations:")
+    st.code(json.dumps(gemini_schemas, indent=2), language="json")
+
+with st.sidebar.expander("⚙️ Raw OpenAI MCP Schemas", expanded=False):
+    st.caption("Internal MCP representation:")
+    st.code(json.dumps(tool_schemas, indent=2), language="json")
+
+# --- 4. EXECUTION HANDLER ---
+def execute_tool(func, args):
+    """Executes tool and returns both raw result and protocol view"""
+    try:
+        # Run the actual function
+        result = func(**args)
+        
+        # Simulate Protocol Response (Agent View)
+        protocol_response = {
+            "content": [],
+            "isError": False
+        }
+        
+        # Format Content Block
+        if isinstance(result, dict) and result.get("type") == "image":
+            # Image protocol format
+            protocol_response["content"].append({
+                "type": "image",
+                "data": result["data"],
+                "mimeType": result.get("mimeType", "image/png")
+            })
+            display_type = "image"
+        elif isinstance(result, (dict, list)):
+            # Structured data usually sent as embedded text JSON
+            text_content = json.dumps(result, indent=2)
+            protocol_response["content"].append({
+                "type": "text",
+                "text": text_content
+            })
+            display_type = "json"
+        else:
+            # Plain text
+            text_result = str(result)
+            protocol_response["content"].append({
+                "type": "text",
+                "text": text_result
+            })
+            display_type = "text"
+            
+        return result, protocol_response, display_type, None
+        
+    except Exception as e:
+        error_resp = {
+            "content": [{"type": "text", "text": str(e)}],
+            "isError": True
+        }
+        return None, error_resp, "error", str(e)
+
+
+# --- 5. UI LOGIC ---
+if not tools:
+    st.error("No tools found.")
+    st.stop()
+
+selected = st.sidebar.radio("Available Tools", sorted(tools.keys()))
+fn = tools[selected]
+sig = inspect.signature(fn)
+
+st.header(f"🔧 {selected}")
+if inspect.getdoc(fn):
+    st.info(inspect.getdoc(fn))
+
+# INPUT TABS
+tab_raw, tab_compact, tab_form = st.tabs(["📄 Raw JSON", "⚡ Compact JSON", "📝 Interactive Form"])
+
+execution_args = None
+trigger_run = False
+
+# --- TAB 1: INTERACTIVE FORM ---
+with tab_form:
+    with st.form("interactive_form"):
+        form_inputs = {}
+        for name, param in sig.parameters.items():
+            if name in ['ctx', 'context']: continue
+            
+            # Type Checking
+            annotation = param.annotation
+            is_number = (annotation in [int, float]) or (getattr(annotation, "__origin__", None) is Union and int in getattr(annotation, "__args__", []))
+            is_bool = (annotation == bool) or (getattr(annotation, "__origin__", None) is Union and bool in getattr(annotation, "__args__", []))
+            
+            if name in ['path', 'source', 'destination']:
+                def_val = str(server.ALLOWED_DIRS[0]) if server.ALLOWED_DIRS else ""
+                form_inputs[name] = st.text_input(name, value=def_val)
+            elif name == 'content':
+                st.caption("Literal Content (WYSIWYG - Enter creates newlines)")
+                form_inputs[name] = st.text_area(name, height=200)
+            elif name == 'edits':
+                st.write("Edits (JSON List)")
+                val = st.text_area("JSON", value='[{"oldText": "foo", "newText": "bar"}]')
+                form_inputs[name] = val # Parse later
+            elif name in ['exclude_patterns', 'paths']:
+                val = st.text_area(f"{name} (one per line)")
+                form_inputs[name] = val
+            elif is_bool:
+                form_inputs[name] = st.checkbox(name)
+            elif is_number:
+                form_inputs[name] = st.number_input(name, value=0)
+            else:
+                form_inputs[name] = st.text_input(name)
+        
+        if st.form_submit_button("Run Form"):
+            # Process Form Inputs
+            try:
+                processed = {}
+                for k, v in form_inputs.items():
+                    # Handle lists
+                    if k in ['exclude_patterns', 'paths']:
+                        processed[k] = [x.strip() for x in v.split('\n') if x.strip()]
+                    # Handle JSON fields
+                    elif k == 'edits':
+                        processed[k] = json.loads(v)
+                    # Handle Optionals
+                    elif v == 0 and k in ['head', 'tail']:
+                        processed[k] = None
+                    else:
+                        processed[k] = v
+                execution_args = processed
+                trigger_run = True
+            except Exception as e:
+                st.error(f"Form Error: {e}")
+
+# --- TAB 2 & 3: JSON INPUTS ---
+# Helper to generate template
+default_args = {}
+for name, param in sig.parameters.items():
+    if name in ['ctx', 'context']: continue
+    if name in ['path', 'source', 'destination']:
+        default_args[name] = str(server.ALLOWED_DIRS[0]) if server.ALLOWED_DIRS else ""
+    elif name == 'content': default_args[name] = "Line 1\nLine 2"
+    elif name == 'paths': default_args[name] = [str(server.ALLOWED_DIRS[0])] if server.ALLOWED_DIRS else []
+    else: default_args[name] = ""
+
+json_template = json.dumps(default_args, indent=2)
+
+with tab_raw:
+    with st.form("json_raw_form"):
+        raw_text = st.text_area("JSON Input", value=json_template, height=300)
+        if st.form_submit_button("Run Raw JSON"):
+            try:
+                execution_args = json.loads(raw_text)
+                trigger_run = True
+            except Exception as e:
+                st.error(f"Invalid JSON: {e}")
+
+with tab_compact:
+    with st.form("json_compact_form"):
+        compact_text = st.text_input("One-line JSON", value=json.dumps(default_args))
+        if st.form_submit_button("Run Compact JSON"):
+            try:
+                execution_args = json.loads(compact_text)
+                trigger_run = True
+            except Exception as e:
+                st.error(f"Invalid JSON: {e}")
+
+# --- OUTPUT DISPLAY ---
+if trigger_run and execution_args is not None:
+    st.divider()
+    
+    with st.spinner("Running tool..."):
+        res_raw, res_proto, dtype, err = execute_tool(fn, execution_args)
+
+    json_response = json.dumps(res_proto, indent=None)
+    escaped_json = json.dumps(json_response)
+    streamlit_js_eval(js_expressions=f"navigator.clipboard.writeText({escaped_json})")
+    if err:
+        st.error("Tool Execution Failed")
+        st.toast("Something went wrong - error copied to clipboard", icon="❌")
+    else:
+        st.success("Tool Execution Successful")
+        st.toast("Tool response copied to clipboard!", icon="✅")
+
+    col_human, col_agent = st.columns(2)
+    
+    with col_human:
+        st.subheader("👀 Human View")
+        if err:
+            st.error(err)
+        elif dtype == "image":
+            st.image(base64.b64decode(res_proto["content"][0]["data"]))
+        elif dtype == "json":
+            st.json(res_raw)
+        else:
+            text = str(res_raw)
+            if text.startswith("---") or text.startswith("+++"):
+                st.code(text, language="diff")
+            else:
+                st.code(text)
+
+    with col_agent:
+        st.subheader("🤖 Agent Protocol View")
+        st.caption("This is exactly what the LLM receives.")
+        st.code(json.dumps(res_proto, indent=None), language="json")

fs_mcp-1.3.2.dist-info/METADATA

@@ -0,0 +1,180 @@
+Metadata-Version: 2.4
+Name: fs-mcp
+Version: 1.3.2
+Summary: A secure MCP filesystem server with Stdio and Web UI modes.
+Author-email: luutuankiet <luutuankiet.ftu2@gmail.com>
+Requires-Python: >=3.10
+Requires-Dist: fastmcp>=0.1.0
+Requires-Dist: google-genai>=1.56.0
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pydantic>=2.0
+Requires-Dist: pyfiglet
+Requires-Dist: streamlit-js-eval>=0.1.5
+Requires-Dist: streamlit>=1.30.0
+Requires-Dist: toml
+Description-Content-Type: text/markdown
+
+# fs-mcp 📂
+
+**The "Human-in-the-Loop" Filesystem MCP Server**
+
+---
+
+https://github.com/user-attachments/assets/132acdd9-014c-4ba0-845a-7db74644e655
+
+## 💡 Why This Exists
+
+I built this because I was tired of jumping through hoops.
+
+The promise of the Model Context Protocol (MCP) is incredible, but the reality of using the standard filesystem server hit a few walls for my workflow:
+
+1.  **The Container Gap:** I do most of my work in Docker. Connecting a local agent (like Claude Desktop) to a filesystem inside a container via Stdio is a networking nightmare.
+2.  **The Free Tier Lockout:** I wanted to use the free tier of [Google AI Studio](https://aistudio.google.com/) to edit code, but you can't easily plug MCP into a web interface.
+3.  **Schema Hell:** Even if you *do* copy-paste schemas into Gemini, they often break because Gemini's strict validation is only a [subset of the standard OpenAPI spec](https://ai.google.dev/gemini-api/docs/function-calling).
+
+**fs-mcp solves this.** It is a Python-based server built on `fastmcp` that treats "Human-in-the-Loop" as a first-class citizen, enabling seamless and interactive collaboration between LLM agents and a developer's local environment.
+
+---
+
+## 🚀 Key Features
+
+### 1. HTTP by Default (Remote Ready)
+
+It runs a background HTTP server alongside the CLI. You can finally connect agents to remote environments or containers without SSH tunneling wizardry.
+
+### 2. Zero-Config Inspector
+
+No `npm install inspector`. I baked a **Streamlit Web UI** directly into the package. Launch it, and you instantly have a visual form to test tools, view results, and generate configs.
+
+### 3. Copy-Paste Gemini Schemas 📋
+
+The UI automatically sanitizes and translates your tool schemas specifically for **Google GenAI**. It strips forbidden keys (`default`, `title`, etc.) so you can paste function definitions directly into AI Studio and start coding for free.
+
+### 4. Human-in-the-Loop Diffing 🤝
+
+The **`propose_and_review`** tool bridges the gap between agent proposals and human oversight. It opens a VS Code diff window for you to inspect changes. 
+
+**How it Works:**
+1. The agent calls `propose_and_review` with a code change.
+2. A VS Code window pops up showing the **Diff**.
+3. **To Approve:** Add a double newline at the very end of the file and Save.
+4. **To Review:** Just edit the code directly in the diff window and Save. The agent will receive your edits as feedback and try again!
+
+```mermaid
+sequenceDiagram
+    participant User
+    participant Agent
+    participant MCP_Server
+
+    User->>Agent: "Propose an edit to README.md"
+    activate Agent
+    Agent->>MCP_Server: call propose_and_review(path="README.md", old, new)
+    activate MCP_Server
+    Note right of MCP_Server: Creates temp files & prints vscode_command.<br/>Now enters "watch loop", waiting for user to save.
+    MCP_Server-->>User: (via console) `code --diff ...`
+    
+    Note right of User: User opens VS Code, is happy with the change,<br/>adds a double newline to the end of the file, and saves.
+    
+    Note right of MCP_Server: Save detected! Checks file content.
+    MCP_Server-->>Agent: return { user_action: "APPROVE", message: "User approved. Call commit_review." }
+    deactivate MCP_Server
+
+    Note right of Agent: Agent sees "APPROVE" and knows what to do next.
+    Agent->>MCP_Server: call commit_review(session_path, original_path="README.md")
+    activate MCP_Server
+    Note right of MCP_Server: Copies 'future' file to original path,<br/>removes the trailing newlines,<br/>and cleans up the temp directory.
+    MCP_Server-->>Agent: return "Successfully committed changes."
+    deactivate MCP_Server
+    
+    Agent-->>User: "Changes have been committed!"
+    deactivate Agent
+```
+
+
+
+---
+
+## ⚡ Quick Start
+
+### Run Instantly
+
+By default, this command launches the **Web UI (8123)** and a **Background HTTP Server (8124)**.
+
+```bash
+# Allow access to the current dir
+uvx fs-mcp .
+```
+
+### Selective Launch
+
+Want to disable a component? Use the flags:
+
+```bash
+# UI Only (No background HTTP)
+fs-mcp --no-http .
+
+# HTTP Only (Headless / Docker mode)
+fs-mcp --no-ui .
+```
+
+---
+
+## 🔌 Configuration
+
+### Claude Desktop (Stdio Mode)
+
+Add this to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "fs-mcp": {
+      "command": "uvx",
+      "args": [
+        "fs-mcp",
+        "/absolute/path/to/your/project"
+      ]
+    }
+  }
+}
+```
+
+### Docker (HTTP Mode)
+
+To run inside a container and expose the filesystem to a local agent:
+
+```bash
+# In your entrypoint or CMD
+uvx fs-mcp --no-ui --http-host 0.0.0.0 --http-port 8124 /app
+```
+
+---
+
+## The Toolbox 🧰
+
+| Tool                       | Description                                                                |
+| -------------------------- | -------------------------------------------------------------------------- |
+| `propose_and_review`       | **Interactive Review:** Opens VS Code diff. Add a double newline to finalize.  |
+| `commit_review`            | Finalizes the changes from an interactive review session.                  |
+| `read_multiple_files`      | Reads content of multiple files to save context window.                    |
+| `directory_tree`           | **Fast:** Returns recursive JSON tree. Skips `.venv`/`.git` automatically. |
+| `search_files`             | Recursive pattern discovery using `rglob`.                                 |
+| `grounding_search`         | **New:** Natural language query for grounded search results.               |
+| `read_text_file`           | Standard text reader (supports `head`/`tail` for large files).             |
+| `list_directory_with_sizes`| Detailed listing including formatted file sizes.                           |
+| `list_allowed_directories` | List security-approved paths.                                              |
+| `get_file_info`            | Metadata retrieval (size, modified time).                                  |
+| `read_media_file`          | Returns base64 encoded images/audio.                                       |
+| `write_file`               | Creates or overwrites files (atomic operations).                           |
+| `create_directory`         | Create a new directory.                                                    |
+| `move_file`                | Move or rename files.                                                      |
+| `append_text`              | Safe fallback for appending content to EOF.                                |
+
+---
+
+## License & Credits
+
+Built with ❤️ for the MCP Community by **luutuankiet**.
+Powered by **FastMCP** and **Streamlit**.
+
+**Now go build some agents.** 🚀

fs_mcp-1.3.2.dist-info/RECORD

@@ -0,0 +1,9 @@
+fs_mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fs_mcp/__main__.py,sha256=DDedxJgD1D-nIy5kyrG1S5Ow2gZESO_3pFf4bXsFBFY,5426
+fs_mcp/http_runner.py,sha256=VFzP4DETV-cM4ShwAHiAJjKSf8nfVFGyl5NPK9v51Tg,814
+fs_mcp/server.py,sha256=VxU3n2tvsnRG183bH777H1TLf0n6z9ddgB4LSLYaJ70,21428
+fs_mcp/web_ui.py,sha256=5-D2yV4AqdX0BpoA7kfR7ccOIL9IASQli0Ol2bjoUyg,14119
+fs_mcp-1.3.2.dist-info/METADATA,sha256=LJ_7htz8hkmxrZH7EmBhPd_xxFh1R22J_EXtiYW1XW4,7123
+fs_mcp-1.3.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+fs_mcp-1.3.2.dist-info/entry_points.txt,sha256=CELnPTTv4c_WWstoX8CPBWUDh4Z8KK0enZQeSxG3wf0,48
+fs_mcp-1.3.2.dist-info/RECORD,,

fs_mcp-1.3.2.dist-info/WHEEL

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

fs_mcp-1.3.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+fs-mcp = fs_mcp.__main__:main