mcp-server-make 0.1.0__tar.gz

mcp_server_make-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv

mcp_server_make-0.1.0/PKG-INFO

@@ -0,0 +1,220 @@
+Metadata-Version: 2.4
+Name: mcp-server-make
+Version: 0.1.0
+Summary: MCP Server for GNU Make
+Project-URL: Homepage, https://github.com/modelcontextprotocol/mcp-server-make
+Project-URL: Documentation, https://github.com/modelcontextprotocol/mcp-server-make#readme
+Project-URL: Repository, https://github.com/modelcontextprotocol/mcp-server-make.git
+Project-URL: Changelog, https://github.com/modelcontextprotocol/mcp-server-make/blob/main/CHANGELOG.md
+Author-email: "Joshua M. Dotson" <contact@jmdots.com>
+License-Expression: MIT
+Keywords: build,claude,llm,make,mcp
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Requires-Dist: mcp>=1.1.2
+Requires-Dist: pydantic>=2.10.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.8.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23.3; extra == 'dev'
+Requires-Dist: pytest-cov>=4.1.0; extra == 'dev'
+Requires-Dist: pytest>=7.4.4; extra == 'dev'
+Requires-Dist: ruff>=0.1.13; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# mcp-server-make
+
+MCP Server for GNU Make - providing controlled and secure access to Make systems from LLMs.
+
+## Features
+
+### Resources
+- `make://current/makefile` - Access current Makefile content securely
+- `make://targets` - List available Make targets with documentation
+
+### Tools
+- `list-targets`: List available Make targets
+  - Returns target names and documentation
+  - Optional pattern filtering for searching targets
+- `run-target`: Execute Make targets safely
+  - Required: target name
+  - Optional: timeout (1-3600 seconds, default 300)
+
+## Quick Start
+
+### Prerequisites
+- Python 3.12+
+- GNU Make
+- pip or uv package manager
+
+### Installation
+
+Using uv (recommended):
+```bash
+uvx mcp-server-make
+```
+
+Using pip:
+```bash
+pip install mcp-server-make
+```
+
+### Claude Desktop Integration
+
+Add to your Claude Desktop configuration:
+
+MacOS:
+```bash
+nano ~/Library/Application\ Support/Claude/claude_desktop_config.json
+```
+
+Windows:
+```bash
+notepad %APPDATA%\Claude\claude_desktop_config.json
+```
+
+Add configuration:
+```json
+{
+  "mcpServers": {
+    "mcp-server-make": {
+      "command": "uv",
+      "args": [
+        "--directory", 
+        "/path/to/server",
+        "run",
+        "mcp-server-make", 
+        "--makefile-dir", "/path/to/project"
+      ]
+    }
+  }
+}
+```
+
+- `--directory`: Path to the installed mcp-server-make package
+- `--makefile-dir`: Directory containing the Makefile to manage
+
+Restart Claude Desktop to activate the Make server.
+
+## Usage Examples
+
+### List Available Targets
+```
+I see you have a Makefile. Can you list the available targets?
+```
+
+### View Target Documentation
+```
+What does the 'build' target do?
+```
+
+### Run Tests
+```
+Please run the test target with a 2 minute timeout.
+```
+
+### View Makefile
+```
+Show me the current Makefile content.
+```
+
+## Development
+
+### Local Development Setup
+```bash
+# Clone repository
+git clone https://github.com/modelcontextprotocol/mcp-server-make
+cd mcp-server-make
+
+# Create virtual environment
+uv venv
+source .venv/bin/activate  # Unix/MacOS
+.venv\Scripts\activate     # Windows
+
+# Install dependencies
+make dev-setup
+
+# Run tests and checks
+make check
+```
+
+### Testing with MCP Inspector
+
+Test the server using the MCP Inspector:
+```bash
+npx @modelcontextprotocol/inspector uv --directory /path/to/mcp-server-make run mcp-server-make --makefile-dir /path/to/project
+```
+
+## Security Features
+
+Version 0.1.0 implements several security controls:
+
+- Path validation and directory boundary enforcement
+- Target name sanitization and command validation
+- Resource and timeout limits for command execution
+- Restricted environment access and cleanup
+- Error isolation and safe propagation
+
+## Behavior Details
+
+### Resource Access
+- Makefile content is read-only and validated
+- Target listing includes names and documentation
+- Full path validation prevents traversal attacks
+- Resources require proper make:// URIs
+
+### Tool Execution
+- Targets are sanitized and validated
+- Execution occurs in controlled environment
+- Timeouts prevent infinite execution
+- Clear error messages for failures
+- Resource cleanup after execution
+
+### Error Handling
+- Type-safe error propagation
+- Context-aware error messages
+- Clean error isolation
+- No error leakage
+
+## Known Limitations
+
+Version 0.1.0 has the following scope limitations:
+
+- Read-only Makefile access
+- Single Makefile per working directory
+- No support for include directives
+- Basic target pattern matching only
+- No variable expansion in documentation
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Add tests for new features
+4. Ensure all checks pass (`make check`)
+5. Submit a pull request
+
+## License
+
+MIT - See LICENSE file for details.
+
+## Support
+
+- GitHub Issues: Bug reports and feature requests
+- GitHub Discussions: Questions and community help
+
+## Version History
+
+### 0.1.0
+- Initial stable release
+- Basic Makefile access and target execution
+- Core security controls
+- Claude Desktop integration
+- Configurable Makefile directory

mcp_server_make-0.1.0/README.md

@@ -0,0 +1,189 @@
+# mcp-server-make
+
+MCP Server for GNU Make - providing controlled and secure access to Make systems from LLMs.
+
+## Features
+
+### Resources
+- `make://current/makefile` - Access current Makefile content securely
+- `make://targets` - List available Make targets with documentation
+
+### Tools
+- `list-targets`: List available Make targets
+  - Returns target names and documentation
+  - Optional pattern filtering for searching targets
+- `run-target`: Execute Make targets safely
+  - Required: target name
+  - Optional: timeout (1-3600 seconds, default 300)
+
+## Quick Start
+
+### Prerequisites
+- Python 3.12+
+- GNU Make
+- pip or uv package manager
+
+### Installation
+
+Using uv (recommended):
+```bash
+uvx mcp-server-make
+```
+
+Using pip:
+```bash
+pip install mcp-server-make
+```
+
+### Claude Desktop Integration
+
+Add to your Claude Desktop configuration:
+
+MacOS:
+```bash
+nano ~/Library/Application\ Support/Claude/claude_desktop_config.json
+```
+
+Windows:
+```bash
+notepad %APPDATA%\Claude\claude_desktop_config.json
+```
+
+Add configuration:
+```json
+{
+  "mcpServers": {
+    "mcp-server-make": {
+      "command": "uv",
+      "args": [
+        "--directory", 
+        "/path/to/server",
+        "run",
+        "mcp-server-make", 
+        "--makefile-dir", "/path/to/project"
+      ]
+    }
+  }
+}
+```
+
+- `--directory`: Path to the installed mcp-server-make package
+- `--makefile-dir`: Directory containing the Makefile to manage
+
+Restart Claude Desktop to activate the Make server.
+
+## Usage Examples
+
+### List Available Targets
+```
+I see you have a Makefile. Can you list the available targets?
+```
+
+### View Target Documentation
+```
+What does the 'build' target do?
+```
+
+### Run Tests
+```
+Please run the test target with a 2 minute timeout.
+```
+
+### View Makefile
+```
+Show me the current Makefile content.
+```
+
+## Development
+
+### Local Development Setup
+```bash
+# Clone repository
+git clone https://github.com/modelcontextprotocol/mcp-server-make
+cd mcp-server-make
+
+# Create virtual environment
+uv venv
+source .venv/bin/activate  # Unix/MacOS
+.venv\Scripts\activate     # Windows
+
+# Install dependencies
+make dev-setup
+
+# Run tests and checks
+make check
+```
+
+### Testing with MCP Inspector
+
+Test the server using the MCP Inspector:
+```bash
+npx @modelcontextprotocol/inspector uv --directory /path/to/mcp-server-make run mcp-server-make --makefile-dir /path/to/project
+```
+
+## Security Features
+
+Version 0.1.0 implements several security controls:
+
+- Path validation and directory boundary enforcement
+- Target name sanitization and command validation
+- Resource and timeout limits for command execution
+- Restricted environment access and cleanup
+- Error isolation and safe propagation
+
+## Behavior Details
+
+### Resource Access
+- Makefile content is read-only and validated
+- Target listing includes names and documentation
+- Full path validation prevents traversal attacks
+- Resources require proper make:// URIs
+
+### Tool Execution
+- Targets are sanitized and validated
+- Execution occurs in controlled environment
+- Timeouts prevent infinite execution
+- Clear error messages for failures
+- Resource cleanup after execution
+
+### Error Handling
+- Type-safe error propagation
+- Context-aware error messages
+- Clean error isolation
+- No error leakage
+
+## Known Limitations
+
+Version 0.1.0 has the following scope limitations:
+
+- Read-only Makefile access
+- Single Makefile per working directory
+- No support for include directives
+- Basic target pattern matching only
+- No variable expansion in documentation
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Add tests for new features
+4. Ensure all checks pass (`make check`)
+5. Submit a pull request
+
+## License
+
+MIT - See LICENSE file for details.
+
+## Support
+
+- GitHub Issues: Bug reports and feature requests
+- GitHub Discussions: Questions and community help
+
+## Version History
+
+### 0.1.0
+- Initial stable release
+- Basic Makefile access and target execution
+- Core security controls
+- Claude Desktop integration
+- Configurable Makefile directory

mcp_server_make-0.1.0/pyproject.toml

@@ -0,0 +1,60 @@
+[project]
+name = "mcp-server-make"
+version = "0.1.0"
+description = "MCP Server for GNU Make"
+readme = "README.md"
+requires-python = ">=3.12"
+license = "MIT"
+keywords = ["mcp", "make", "build", "llm", "claude"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Build Tools",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+dependencies = [
+    "mcp>=1.1.2",
+    "pydantic>=2.10.0",
+]
+
+[[project.authors]]
+name = "Joshua M. Dotson"
+email = "contact@jmdots.com"
+
+[project.urls]
+Homepage = "https://github.com/modelcontextprotocol/mcp-server-make"
+Documentation = "https://github.com/modelcontextprotocol/mcp-server-make#readme"
+Repository = "https://github.com/modelcontextprotocol/mcp-server-make.git"
+Changelog = "https://github.com/modelcontextprotocol/mcp-server-make/blob/main/CHANGELOG.md"
+
+[project.scripts]
+mcp-server-make = "mcp_server_make:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build]
+include = [
+    "src/**/*.py",
+    "README.md",
+    "LICENSE",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/mcp_server_make"]
+
+[project.optional-dependencies]
+dev = [
+    "ruff>=0.1.13",
+    "mypy>=1.8.0",
+    "pytest>=7.4.4",
+    "pytest-cov>=4.1.0",
+    "pytest-asyncio>=0.23.3",
+]

mcp_server_make-0.1.0/src/mcp_server_make/__init__.py

@@ -0,0 +1,18 @@
+"""MCP Server for GNU Make."""
+
+import asyncio
+
+from . import exceptions
+from . import make
+from . import security
+from . import execution
+from . import handlers
+from .server import main as async_main
+
+__version__ = "0.1.0"
+__all__ = ["main", "exceptions", "make", "security", "execution", "handlers"]
+
+
+def main():
+    """CLI entrypoint that runs the async main function."""
+    asyncio.run(async_main())

mcp_server_make-0.1.0/src/mcp_server_make/exceptions.py

@@ -0,0 +1,13 @@
+"""Custom exceptions for the MCP Make Server."""
+
+
+class MakefileError(Exception):
+    """Raised when there are issues with Makefile operations."""
+
+    pass
+
+
+class SecurityError(Exception):
+    """Raised for security-related violations."""
+
+    pass

mcp_server_make-0.1.0/src/mcp_server_make/execution.py

@@ -0,0 +1,77 @@
+"""Make target execution management with safety controls."""
+
+import asyncio
+import os
+from pathlib import Path
+
+from .exceptions import MakefileError
+from .make import VALID_TARGET_PATTERN
+from .security import get_safe_environment, get_validated_path
+
+
+class ExecutionManager:
+    """Manage Make target execution with safety controls."""
+
+    def __init__(self, base_dir: Path, timeout: int = 300):
+        """Initialize execution manager.
+
+        Args:
+            base_dir: Directory containing the Makefile
+            timeout: Maximum execution time in seconds
+        """
+        self.base_dir = base_dir
+        self.timeout = timeout
+        self.start_time = 0
+        self._original_cwd = None
+
+    async def __aenter__(self):
+        self.start_time = asyncio.get_event_loop().time()
+
+        # Store current directory and change to Makefile directory
+        self._original_cwd = Path.cwd()
+        makefile_dir = get_validated_path(self.base_dir)
+        os.chdir(str(makefile_dir))
+
+        return self
+
+    async def run_target(self, target: str) -> str:
+        """
+        Run a Make target with safety controls.
+
+        Args:
+            target: Name of the target to run
+
+        Returns:
+            Command output as string
+        """
+        if not VALID_TARGET_PATTERN.match(target):
+            raise ValueError(f"Invalid target name: {target}")
+
+        env = get_safe_environment()
+
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                "make",
+                target,
+                env=env,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+
+            stdout, stderr = await asyncio.wait_for(
+                proc.communicate(), timeout=self.timeout
+            )
+
+            if proc.returncode != 0:
+                error_msg = stderr.decode().strip()
+                raise MakefileError(f"Target execution failed: {error_msg}")
+
+            return stdout.decode()
+
+        except asyncio.TimeoutError:
+            raise MakefileError(f"Target execution exceeded {self.timeout}s timeout")
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        # Restore original working directory
+        if self._original_cwd:
+            os.chdir(str(self._original_cwd))

mcp_server_make-0.1.0/src/mcp_server_make/handlers.py

@@ -0,0 +1,228 @@
+"""MCP protocol handlers for Make server functionality."""
+
+import re
+from pathlib import Path
+from typing import List, Optional
+from urllib.parse import quote, unquote, urlparse
+
+from pydantic import AnyUrl
+import mcp.types as types
+
+from .exceptions import MakefileError, SecurityError
+from .execution import ExecutionManager
+from .make import parse_makefile_targets, read_makefile, validate_makefile_syntax
+from .security import get_validated_path
+
+
+def create_make_url(path: str) -> AnyUrl:
+    """Create a properly formatted MCP URI for the Make server.
+
+    Args:
+        path: Path without scheme (e.g. "current/makefile" or "targets")
+
+    Returns:
+        AnyUrl for Make server (e.g. "make://current/makefile")
+    """
+    # Clean and normalize path
+    path = path.strip().strip("/")
+
+    # Use "localhost" as host to ensure path is preserved
+    uri = f"make://localhost/{quote(path, safe='/')}"
+    return AnyUrl(uri)
+
+
+def normalize_uri_path(uri: AnyUrl) -> str:
+    """Normalize a URI path for consistent comparison.
+
+    Args:
+        uri: URI to normalize path from
+
+    Returns:
+        Normalized path string
+
+    Raises:
+        ValueError: If URI has no valid path
+    """
+    parsed = urlparse(str(uri))
+    if not parsed.path or parsed.path == "/":
+        raise ValueError("URI must have a path component")
+
+    # Remove leading/trailing slashes and normalize
+    path = unquote(parsed.path.strip("/"))
+    return path.lower()
+
+
+async def handle_list_resources(makefile_dir: Path) -> list[types.Resource]:
+    """List available Make-related resources.
+
+    Args:
+        makefile_dir: Directory containing the Makefile
+    """
+    resources = []
+
+    try:
+        # Add Makefile resource if it exists
+        makefile_path = get_validated_path(makefile_dir, "Makefile")
+        if makefile_path.exists():
+            resources.append(
+                types.Resource(
+                    uri=create_make_url("current/makefile"),
+                    name="Current Makefile",
+                    description="Contents of the current Makefile",
+                    mimeType="text/plain",
+                )
+            )
+
+            # Only add targets if we have a readable Makefile
+            targets = await parse_makefile_targets(makefile_dir)
+            if targets:
+                resources.append(
+                    types.Resource(
+                        uri=create_make_url("targets"),
+                        name="Make Targets",
+                        description="List of available Make targets",
+                        mimeType="application/json",
+                    )
+                )
+
+    except Exception as e:
+        print(f"Error listing resources: {e}")
+
+    return resources
+
+
+async def handle_read_resource(uri: AnyUrl, makefile_dir: Path) -> str:
+    """Read Make-related resource content.
+
+    Args:
+        uri: Resource URI to read (e.g. "make://current/makefile")
+        makefile_dir: Directory containing the Makefile
+
+    Returns:
+        Resource content as string
+
+    Raises:
+        ValueError: If URI is invalid or resource not found
+    """
+    # Validate scheme before path normalization
+    parsed = urlparse(str(uri))
+    if parsed.scheme != "make":
+        raise ValueError(f"Unsupported URI scheme: {parsed.scheme}")
+
+    try:
+        # Normalize the path for consistent comparison
+        norm_path = normalize_uri_path(uri)
+
+        if norm_path == "current/makefile":
+            file_path = get_validated_path(makefile_dir, "Makefile")
+            content = await read_makefile(file_path)
+            validate_makefile_syntax(content)
+            return content
+
+        elif norm_path == "targets":
+            targets = await parse_makefile_targets(makefile_dir)
+            return str(targets)
+
+        raise ValueError(f"Unknown resource path: {norm_path}")
+
+    except (MakefileError, SecurityError) as e:
+        raise ValueError(str(e))
+    except Exception as e:
+        raise ValueError(f"Error reading resource: {str(e)}")
+
+
+async def handle_list_tools() -> List[types.Tool]:
+    """List available Make-related tools."""
+    return [
+        types.Tool(
+            name="list-targets",
+            description="List available Make targets",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "pattern": {
+                        "type": "string",
+                        "description": "Optional filter pattern",
+                    }
+                },
+            },
+        ),
+        types.Tool(
+            name="run-target",
+            description="Execute a Make target",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "target": {"type": "string", "description": "Target to execute"},
+                    "timeout": {
+                        "type": "integer",
+                        "minimum": 1,
+                        "maximum": 3600,
+                        "default": 300,
+                        "description": "Maximum execution time in seconds",
+                    },
+                },
+                "required": ["target"],
+            },
+        ),
+    ]
+
+
+async def handle_call_tool(
+    name: str,
+    arguments: Optional[dict],
+    makefile_dir: Path,
+) -> list[types.TextContent | types.ImageContent | types.EmbeddedResource]:
+    """Execute a Make-related tool.
+
+    Args:
+        name: Tool name to execute
+        arguments: Optional tool arguments
+        makefile_dir: Directory containing the Makefile
+
+    Returns:
+        List of tool result content
+
+    Raises:
+        ValueError: If tool not found or invalid arguments
+    """
+    if not arguments:
+        raise ValueError("Tool arguments required")
+
+    if name == "list-targets":
+        pattern = arguments.get("pattern", "*")
+        targets = await parse_makefile_targets(makefile_dir)
+
+        # Apply pattern filtering if specified
+        if pattern != "*":
+            try:
+                pattern_re = re.compile(pattern)
+                targets = [t for t in targets if pattern_re.search(t["name"])]
+            except re.error:
+                raise ValueError(f"Invalid pattern: {pattern}")
+
+        return [
+            types.TextContent(
+                type="text",
+                text="\n".join(
+                    f"{t['name']}: {t['description'] or 'No description'}"
+                    for t in targets
+                ),
+            )
+        ]
+
+    elif name == "run-target":
+        if "target" not in arguments:
+            raise ValueError("Target name required")
+
+        target = arguments["target"]
+        timeout = min(int(arguments.get("timeout", 300)), 3600)
+
+        try:
+            async with ExecutionManager(base_dir=makefile_dir, timeout=timeout) as mgr:
+                output = await mgr.run_target(target)
+                return [types.TextContent(type="text", text=output)]
+        except (MakefileError, SecurityError) as e:
+            raise ValueError(str(e))
+
+    raise ValueError(f"Unknown tool: {name}")

mcp_server_make-0.1.0/src/mcp_server_make/make.py

@@ -0,0 +1,99 @@
+"""Core Make functionality for the MCP Make Server."""
+
+import asyncio
+import re
+from pathlib import Path
+from typing import List
+
+from .exceptions import MakefileError
+from .security import get_validated_path
+
+# Regular expression for validating Make target names
+VALID_TARGET_PATTERN = re.compile(r"^[a-zA-Z0-9][a-zA-Z0-9_-]*$")
+
+
+async def read_makefile(path: Path) -> str:
+    """
+    Safely read a Makefile's contents.
+
+    Args:
+        path: Path to the Makefile
+
+    Returns:
+        Contents of the Makefile as string
+    """
+    try:
+        async with asyncio.Lock():  # Ensure thread-safe file access
+            return path.read_text()
+    except Exception as e:
+        raise MakefileError(f"Failed to read Makefile: {str(e)}")
+
+
+def validate_makefile_syntax(content: str) -> bool:
+    """
+    Perform basic Makefile syntax validation.
+
+    Args:
+        content: Makefile content to validate
+
+    Returns:
+        True if validation passes
+
+    Raises:
+        MakefileError: If validation fails
+    """
+    try:
+        # Basic syntax checks (can be expanded)
+        if not content.strip():
+            raise MakefileError("Empty Makefile")
+
+        # Check for basic format validity
+        lines = content.splitlines()
+        for i, line in enumerate(lines, 1):
+            if line.strip().startswith(".") and ":" not in line:
+                raise MakefileError(f"Invalid directive on line {i}: {line}")
+
+        return True
+    except Exception as e:
+        raise MakefileError(f"Makefile validation failed: {str(e)}")
+
+
+async def parse_makefile_targets(makefile_dir: Path) -> List[dict]:
+    """
+    Parse Makefile to extract targets and their metadata.
+
+    Args:
+        makefile_dir: Directory containing the Makefile to parse
+
+    Returns:
+        List of target dictionaries with metadata
+    """
+    path = get_validated_path(makefile_dir, "Makefile")
+    content = await read_makefile(path)
+
+    targets = []
+    current_comment = []
+    current_description = None
+
+    for line in content.splitlines():
+        line = line.strip()
+
+        if line.startswith("#"):
+            current_comment.append(line[1:].strip())
+        elif ":" in line and not line.startswith("\t"):
+            target = line.split(":", 1)[0].strip()
+
+            # Extract description from ## comment if present
+            description_parts = line.split("##", 1)
+            if len(description_parts) > 1:
+                current_description = description_parts[1].strip()
+
+            if VALID_TARGET_PATTERN.match(target):
+                description = current_description or " ".join(current_comment) or None
+                targets.append({"name": target, "description": description})
+            current_comment = []
+            current_description = None
+        else:
+            current_comment = []
+
+    return targets

mcp_server_make-0.1.0/src/mcp_server_make/security.py

@@ -0,0 +1,52 @@
+"""Security controls for the MCP Make Server."""
+
+from pathlib import Path
+from typing import Optional
+
+from .exceptions import SecurityError
+
+
+def get_validated_path(base_dir: Path, subpath: Optional[str] = None) -> Path:
+    """
+    Validate and resolve a path within project boundaries.
+
+    Args:
+        base_dir: Base directory containing Makefile (project root)
+        subpath: Optional path relative to base_dir
+
+    Returns:
+        Resolved Path object
+
+    Raises:
+        SecurityError: If path validation fails
+    """
+    try:
+        # Resolve the base directory
+        base = base_dir.resolve()
+
+        # If no subpath, return base
+        if subpath is None:
+            return base
+
+        # Resolve requested path relative to base
+        requested = (base / subpath).resolve()
+
+        # Ensure path is within base directory tree
+        if not str(requested).startswith(str(base)):
+            raise SecurityError("Path access denied: outside project boundary")
+
+        return requested
+    except Exception as e:
+        raise SecurityError(f"Invalid path: {str(e)}")
+
+
+def get_safe_environment() -> dict:
+    """Get a sanitized environment for Make execution."""
+    import os
+
+    env = os.environ.copy()
+    # Remove potentially dangerous variables
+    for key in list(env.keys()):
+        if key.startswith(("LD_", "DYLD_", "PATH")):
+            del env[key]
+    return env

mcp_server_make-0.1.0/src/mcp_server_make/server.py

@@ -0,0 +1,138 @@
+"""MCP Server for GNU Make - Core functionality."""
+
+import argparse
+import asyncio
+from pathlib import Path
+from typing import Any, List
+from urllib.parse import urlparse
+
+from pydantic import AnyUrl
+from mcp.server import (
+    NotificationOptions,
+    Server,
+)
+import mcp.server.stdio
+import mcp.types as types
+from mcp.server.models import InitializationOptions
+
+from . import handlers
+from .exceptions import SecurityError
+
+
+class MakeServer(Server):
+    """MCP Server implementation for GNU Make functionality."""
+
+    def __init__(self, makefile_dir: Path | str | None = None):
+        """Initialize the Make server.
+
+        Args:
+            makefile_dir: Directory containing the Makefile to manage
+        """
+        super().__init__("mcp-server-make")
+
+        # Resolve and validate the Makefile directory
+        self.makefile_dir = Path(makefile_dir).resolve() if makefile_dir else Path.cwd()
+        if not (self.makefile_dir / "Makefile").exists():
+            raise SecurityError(f"No Makefile found in directory: {self.makefile_dir}")
+
+        self._init_handlers()
+
+    def _init_handlers(self) -> None:
+        """Initialize the handler functions."""
+
+        async def _list_resources() -> List[types.Resource]:
+            try:
+                return await handlers.handle_list_resources(self.makefile_dir)
+            except Exception as e:
+                raise ValueError(str(e))
+
+        async def _read_resource(uri: AnyUrl | str) -> str:
+            try:
+                # Handle invalid URI scheme early
+                if isinstance(uri, str):
+                    parsed = urlparse(uri)
+                    if parsed.scheme != "make":
+                        raise ValueError(f"Unsupported URI scheme: {parsed.scheme}")
+                    # Only remove prefix if it's the make:// scheme
+                    uri = handlers.create_make_url(
+                        uri[7:] if uri.startswith("make://") else uri
+                    )
+
+                return await handlers.handle_read_resource(uri, self.makefile_dir)
+            except ValueError as e:
+                # Preserve original error messages
+                raise ValueError(str(e))
+            except Exception as e:
+                raise ValueError(f"Failed to read resource: {str(e)}")
+
+        async def _list_tools() -> List[types.Tool]:
+            try:
+                return await handlers.handle_list_tools()
+            except Exception as e:
+                raise ValueError(str(e))
+
+        async def _call_tool(
+            name: str,
+            arguments: dict | None,
+        ) -> list[types.TextContent | types.ImageContent | types.EmbeddedResource]:
+            try:
+                return await handlers.handle_call_tool(
+                    name, arguments, self.makefile_dir
+                )
+            except Exception as e:
+                raise ValueError(str(e))
+
+        self._list_resources_handler = _list_resources
+        self._read_resource_handler = _read_resource
+        self._list_tools_handler = _list_tools
+        self._call_tool_handler = _call_tool
+
+    @property
+    def list_resources(self) -> Any:
+        """Return list_resources handler."""
+        return self._list_resources_handler
+
+    @property
+    def read_resource(self) -> Any:
+        """Return read_resource handler."""
+        return self._read_resource_handler
+
+    @property
+    def list_tools(self) -> Any:
+        """Return list_tools handler."""
+        return self._list_tools_handler
+
+    @property
+    def call_tool(self) -> Any:
+        """Return call_tool handler."""
+        return self._call_tool_handler
+
+
+async def main():
+    """Run the server using stdin/stdout streams."""
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description="MCP Server for GNU Make")
+    parser.add_argument(
+        "--makefile-dir",
+        type=str,
+        help="Directory containing the Makefile to manage",
+    )
+    args = parser.parse_args()
+
+    # Create server instance with configured directory
+    server = MakeServer(makefile_dir=args.makefile_dir)
+
+    async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
+        init_options = InitializationOptions(
+            server_name="mcp-server-make",
+            server_version="0.1.0",
+            capabilities=server.get_capabilities(
+                notification_options=NotificationOptions(),
+                experimental_capabilities={},
+            ),
+        )
+        await server.run(read_stream, write_stream, init_options)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())