model_context_protocol_demo 0.1.0__py3-none-any.whl

model_context_protocol_demo/main.py

@@ -0,0 +1,7 @@
+from model_context_protocol_demo.server import mcp 
+
+def main():
+    mcp.run(transport="stdio")
+
+if __name__ == "__main__":
+    main()

model_context_protocol_demo/server.py

@@ -0,0 +1,443 @@
+from __future__ import annotations
+import glob as glob_module
+import logging
+import logging.handlers
+import os
+import re
+import shlex
+import subprocess
+import sys
+import time
+import uuid
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Optional
+
+from fastmcp import FastMCP
+
+SANDBOX_ROOT = Path(os.environ.get("MCP_SANDBOX_ROOT", os.getcwd())).resolve()
+CMD_TIMEOUT = float(os.environ.get("MCP_CMD_TIMEOUT", "30"))
+MAX_OUTPUT_BYTES = int(os.environ.get("MCP_MAX_OUTPUT_BYTES", "200000"))
+LOG_DIR = Path(os.environ.get("MCP_LOG_DIR", "./logs")).resolve()
+LOG_LEVEL = os.environ.get("MCP_LOG_LEVEL", "INFO").upper()
+
+SANDBOX_ROOT.mkdir(parents=True, exist_ok=True)
+LOG_DIR.mkdir(parents=True, exist_ok=True)
+
+logger = logging.getLogger("mcp_tool_server")
+logger.setLevel(LOG_LEVEL)
+logger.propagate = False
+
+mcp = FastMCP()
+
+if not logger.handlers:
+    fmt = logging.Formatter(
+        "%(asctime)s | %(levelname)-8s | %(name)s | %(message)s"
+    )
+
+    console_handler = logging.StreamHandler(sys.stderr)
+    console_handler.setFormatter(fmt)
+    logger.addHandler(console_handler)
+
+    file_handler = logging.handlers.RotatingFileHandler(
+        LOG_DIR / "mcp_tool_server.log",
+        maxBytes=10 * 1024 * 1024,
+        backupCount=5,
+        encoding="utf-8",
+    )
+    file_handler.setFormatter(fmt)
+    logger.addHandler(file_handler)
+
+
+def new_request_id() -> str:
+    return uuid.uuid4().hex[:12]
+
+@dataclass
+class ToolResult:
+    ok: bool
+    output: str = ""
+    error: Optional[str] = None
+    meta: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "ok": self.ok,
+            "output": self.output,
+            "error": self.error,
+            "meta": self.meta,
+        }
+
+
+def _truncate(text: str, limit: int = MAX_OUTPUT_BYTES) -> tuple[str, bool]:
+    encoded = text.encode("utf-8", errors="replace")
+    if len(encoded) <= limit:
+        return text, False
+    truncated = encoded[:limit].decode("utf-8", errors="ignore")
+    return truncated, True
+
+
+class PathSecurityError(Exception):
+    pass
+
+
+def resolve_safe_path(user_path: str) -> Path:
+    """Resolve `user_path` (relative or absolute) against SANDBOX_ROOT and
+    guarantee the result stays inside it. Raises PathSecurityError otherwise.
+    """
+    candidate = (SANDBOX_ROOT / user_path).resolve() if not os.path.isabs(user_path) \
+        else Path(user_path).resolve()
+
+    try:
+        candidate.relative_to(SANDBOX_ROOT)
+    except ValueError:
+        raise PathSecurityError(
+            f"Path '{user_path}' resolves outside the sandbox root "
+            f"'{SANDBOX_ROOT}'. Operation blocked."
+        )
+    return candidate
+
+def run_subprocess(
+    args: list[str] | str,
+    *,
+    shell: bool,
+    timeout: float,
+    cwd: Path,
+    request_id: str,
+) -> ToolResult:
+    start = time.monotonic()
+    try:
+        proc = subprocess.run(
+            args,
+            shell=shell,
+            cwd=str(cwd),
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            timeout=timeout,
+        )
+        elapsed = round(time.monotonic() - start, 3)
+        stdout, out_trunc = _truncate(proc.stdout.decode("utf-8", errors="replace"))
+        stderr, err_trunc = _truncate(proc.stderr.decode("utf-8", errors="replace"))
+
+        meta = {
+            "request_id": request_id,
+            "return_code": proc.returncode,
+            "elapsed_seconds": elapsed,
+            "stdout_truncated": out_trunc,
+            "stderr_truncated": err_trunc,
+            "cwd": str(cwd),
+        }
+
+        if proc.returncode == 0:
+            logger.info("[%s] command succeeded in %ss", request_id, elapsed)
+            return ToolResult(ok=True, output=stdout, error=stderr or None, meta=meta)
+        else:
+            logger.warning(
+                "[%s] command exited %s in %ss", request_id, proc.returncode, elapsed
+            )
+            return ToolResult(
+                ok=False,
+                output=stdout,
+                error=stderr or f"Process exited with code {proc.returncode}",
+                meta=meta,
+            )
+
+    except subprocess.TimeoutExpired:
+        elapsed = round(time.monotonic() - start, 3)
+        logger.error("[%s] command timed out after %ss", request_id, elapsed)
+        return ToolResult(
+            ok=False,
+            error=f"Command timed out after {timeout} seconds.",
+            meta={"request_id": request_id, "elapsed_seconds": elapsed},
+        )
+    except FileNotFoundError as e:
+        logger.error("[%s] executable not found: %s", request_id, e)
+        return ToolResult(
+            ok=False, error=f"Executable not found: {e}", meta={"request_id": request_id}
+        )
+    except Exception as e:  # noqa: BLE001 - last-resort guard, never leak raw tracebacks
+        logger.exception("[%s] unexpected error running command", request_id)
+        return ToolResult(
+            ok=False, error=f"Unexpected error: {e}", meta={"request_id": request_id}
+        )
+
+@mcp.tool()
+def bash(command: str, timeout: Optional[float] = None) -> dict:
+    """Execute a bash command inside the sandboxed working directory and
+    return a structured result: {ok, output, error, meta}.
+
+    Blocked: attempts to escape the sandbox root via path traversal in
+    obviously destructive patterns (e.g. `rm -rf /`) are not specially
+    parsed — the sandbox is enforced at the cwd/path-tool level, not by
+    command inspection. Treat this tool as trusted-user-only.
+    """
+    request_id = new_request_id()
+    logger.info("[%s] bash: %s", request_id, command)
+
+    if not command or not command.strip():
+        return ToolResult(ok=False, error="Empty command.").to_dict()
+
+    result = run_subprocess(
+        command,
+        shell=True,
+        timeout=timeout or CMD_TIMEOUT,
+        cwd=SANDBOX_ROOT,
+        request_id=request_id,
+    )
+    return result.to_dict()
+
+
+@mcp.tool()
+def python_code(code: str, timeout: Optional[float] = None) -> dict:
+    """Execute a Python code snippet in a subprocess and return a structured
+    result: {ok, output, error, meta}.
+    """
+    request_id = new_request_id()
+    logger.info("[%s] python_code: %d chars", request_id, len(code or ""))
+
+    if not code or not code.strip():
+        return ToolResult(ok=False, error="Empty code.").to_dict()
+
+    result = run_subprocess(
+        [sys.executable, "-c", code],
+        shell=False,
+        timeout=timeout or CMD_TIMEOUT,
+        cwd=SANDBOX_ROOT,
+        request_id=request_id,
+    )
+    return result.to_dict()
+
+
+@mcp.tool()
+def python_file(file: str, args: Optional[list[str]] = None, timeout: Optional[float] = None) -> dict:
+    """Execute a Python file (path relative to the sandbox root, or an
+    absolute path inside it) and return a structured result.
+    """
+    request_id = new_request_id()
+    try:
+        safe_path = resolve_safe_path(file)
+    except PathSecurityError as e:
+        logger.warning("[%s] blocked path: %s", request_id, e)
+        return ToolResult(ok=False, error=str(e)).to_dict()
+
+    if not safe_path.is_file():
+        return ToolResult(ok=False, error=f"File not found: {file}").to_dict()
+
+    cmd = [sys.executable, str(safe_path), *(args or [])]
+    logger.info("[%s] python_file: %s", request_id, " ".join(shlex.quote(c) for c in cmd))
+
+    result = run_subprocess(
+        cmd,
+        shell=False,
+        timeout=timeout or CMD_TIMEOUT,
+        cwd=SANDBOX_ROOT,
+        request_id=request_id,
+    )
+    return result.to_dict()
+
+
+@mcp.tool()
+def glob(pattern: str, recursive: bool = True) -> dict:
+    """Return files matching `pattern` within the sandbox root.
+    `pattern` is interpreted relative to the sandbox root unless absolute
+    (absolute paths outside the sandbox are rejected).
+    """
+    request_id = new_request_id()
+    try:
+        base = pattern if os.path.isabs(pattern) else str(SANDBOX_ROOT / pattern)
+        matches = glob_module.glob(base, recursive=recursive)
+
+        safe_matches = []
+        for m in matches:
+            try:
+                Path(m).resolve().relative_to(SANDBOX_ROOT)
+                safe_matches.append(m)
+            except ValueError:
+                continue  # silently drop anything outside the sandbox
+
+        logger.info("[%s] glob(%s) -> %d matches", request_id, pattern, len(safe_matches))
+        return ToolResult(ok=True, output="\n".join(safe_matches), meta={
+            "request_id": request_id, "count": len(safe_matches)
+        }).to_dict()
+    except Exception as e:  # noqa: BLE001
+        logger.exception("[%s] glob failed", request_id)
+        return ToolResult(ok=False, error=str(e)).to_dict()
+
+
+@mcp.tool()
+def grep(pattern: str, file: str, ignore_case: bool = False, max_matches: int = 500) -> dict:
+    """Search for a regex `pattern` in `file` (relative to sandbox root) and
+    return matching lines with their line numbers. Cross-platform (pure
+    Python regex, not shell-dependent like findstr/grep).
+    """
+    request_id = new_request_id()
+    try:
+        safe_path = resolve_safe_path(file)
+    except PathSecurityError as e:
+        return ToolResult(ok=False, error=str(e)).to_dict()
+
+    if not safe_path.is_file():
+        return ToolResult(ok=False, error=f"File not found: {file}").to_dict()
+
+    try:
+        flags = re.IGNORECASE if ignore_case else 0
+        regex = re.compile(pattern, flags)
+    except re.error as e:
+        return ToolResult(ok=False, error=f"Invalid regex: {e}").to_dict()
+
+    matches = []
+    try:
+        with safe_path.open("r", encoding="utf-8", errors="replace") as f:
+            for lineno, line in enumerate(f, start=1):
+                if regex.search(line):
+                    matches.append(f"{lineno}:{line.rstrip(chr(10))}")
+                    if len(matches) >= max_matches:
+                        break
+    except Exception as e:  # noqa: BLE001
+        logger.exception("[%s] grep failed", request_id)
+        return ToolResult(ok=False, error=str(e)).to_dict()
+
+    logger.info("[%s] grep(%s, %s) -> %d matches", request_id, pattern, file, len(matches))
+    return ToolResult(
+        ok=True,
+        output="\n".join(matches),
+        meta={"request_id": request_id, "count": len(matches)},
+    ).to_dict()
+
+
+@mcp.tool()
+def read_file(file: str, max_bytes: Optional[int] = None) -> dict:
+    """Read a file's contents (path relative to sandbox root)."""
+    request_id = new_request_id()
+    try:
+        safe_path = resolve_safe_path(file)
+    except PathSecurityError as e:
+        return ToolResult(ok=False, error=str(e)).to_dict()
+
+    if not safe_path.is_file():
+        return ToolResult(ok=False, error=f"File not found: {file}").to_dict()
+
+    try:
+        limit = max_bytes or MAX_OUTPUT_BYTES
+        with safe_path.open("rb") as f:
+            raw = f.read(limit + 1)
+        truncated = len(raw) > limit
+        text = raw[:limit].decode("utf-8", errors="replace")
+        return ToolResult(
+            ok=True, output=text,
+            meta={"request_id": request_id, "truncated": truncated, "size_bytes": safe_path.stat().st_size},
+        ).to_dict()
+    except Exception as e:  # noqa: BLE001
+        logger.exception("[%s] read_file failed", request_id)
+        return ToolResult(ok=False, error=str(e)).to_dict()
+
+
+@mcp.tool()
+def write_file(file: str, content: str, overwrite: bool = True, append: bool = False) -> dict:
+    """Write `content` to `file` (relative to sandbox root). Creates parent
+    directories as needed. Set overwrite=False to fail if the file already
+    exists; set append=True to append instead of replacing.
+    """
+    request_id = new_request_id()
+    try:
+        safe_path = resolve_safe_path(file)
+    except PathSecurityError as e:
+        return ToolResult(ok=False, error=str(e)).to_dict()
+
+    if safe_path.exists() and not overwrite and not append:
+        return ToolResult(ok=False, error=f"File already exists: {file}").to_dict()
+
+    try:
+        safe_path.parent.mkdir(parents=True, exist_ok=True)
+        mode = "a" if append else "w"
+        with safe_path.open(mode, encoding="utf-8") as f:
+            f.write(content)
+        logger.info("[%s] wrote %d chars to %s", request_id, len(content), safe_path)
+        return ToolResult(
+            ok=True,
+            output=f"Content written to {file} successfully.",
+            meta={"request_id": request_id, "bytes_written": len(content.encode('utf-8'))},
+        ).to_dict()
+    except Exception as e:  # noqa: BLE001
+        logger.exception("[%s] write_file failed", request_id)
+        return ToolResult(ok=False, error=str(e)).to_dict()
+
+
+@mcp.tool()
+def create_folder(folder: str) -> dict:
+    """Create a folder (relative to sandbox root), including parents."""
+    request_id = new_request_id()
+    try:
+        safe_path = resolve_safe_path(folder)
+    except PathSecurityError as e:
+        return ToolResult(ok=False, error=str(e)).to_dict()
+
+    try:
+        if safe_path.exists():
+            return ToolResult(
+                ok=True, output=f"Folder '{folder}' already exists.",
+                meta={"request_id": request_id, "created": False},
+            ).to_dict()
+        safe_path.mkdir(parents=True, exist_ok=False)
+        logger.info("[%s] created folder %s", request_id, safe_path)
+        return ToolResult(
+            ok=True, output=f"Folder '{folder}' created successfully.",
+            meta={"request_id": request_id, "created": True},
+        ).to_dict()
+    except Exception as e:  # noqa: BLE001
+        logger.exception("[%s] create_folder failed", request_id)
+        return ToolResult(ok=False, error=str(e)).to_dict()
+
+
+@mcp.tool()
+def delete_folder(folder: str, confirm: bool = False) -> dict:
+    """Delete a folder (relative to sandbox root) and everything in it.
+    Requires confirm=True as a safety guard against accidental calls.
+    Refuses to delete the sandbox root itself.
+    """
+    request_id = new_request_id()
+    if not confirm:
+        return ToolResult(
+            ok=False,
+            error="Destructive operation requires confirm=True.",
+        ).to_dict()
+
+    try:
+        safe_path = resolve_safe_path(folder)
+    except PathSecurityError as e:
+        return ToolResult(ok=False, error=str(e)).to_dict()
+
+    if safe_path == SANDBOX_ROOT:
+        return ToolResult(ok=False, error="Refusing to delete the sandbox root.").to_dict()
+
+    if not safe_path.exists():
+        return ToolResult(ok=True, output=f"Folder '{folder}' does not exist.",
+                           meta={"request_id": request_id, "deleted": False}).to_dict()
+
+    try:
+        import shutil
+        shutil.rmtree(safe_path)
+        logger.warning("[%s] deleted folder %s", request_id, safe_path)
+        return ToolResult(
+            ok=True, output=f"Folder '{folder}' deleted successfully.",
+            meta={"request_id": request_id, "deleted": True},
+        ).to_dict()
+    except Exception as e:  # noqa: BLE001
+        logger.exception("[%s] delete_folder failed", request_id)
+        return ToolResult(ok=False, error=str(e)).to_dict()
+
+
+@mcp.tool()
+def health_check() -> dict:
+    """Report server health/config — useful for monitoring and smoke tests."""
+    return ToolResult(
+        ok=True,
+        output="healthy",
+        meta={
+            "sandbox_root": str(SANDBOX_ROOT),
+            "cmd_timeout": CMD_TIMEOUT,
+            "max_output_bytes": MAX_OUTPUT_BYTES,
+            "log_dir": str(LOG_DIR),
+            "log_level": LOG_LEVEL,
+            "pid": os.getpid(),
+        },
+    ).to_dict()

model_context_protocol_demo-0.1.0.dist-info/METADATA

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: model_context_protocol_demo
+Version: 0.1.0
+Summary: An MCP which adds terminal capabilities to an agent.
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: fastmcp>=3.4.3

model_context_protocol_demo-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+model_context_protocol_demo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+model_context_protocol_demo/main.py,sha256=WyO8xAYhuSdFZX3P-thRC9KAOFob4UzskO17evwTOuM,140
+model_context_protocol_demo/server.py,sha256=v18w-ohLMnO3rWmDBD4KUPla7wAPMm1TY0xzoRevz1Y,15968
+model_context_protocol_demo-0.1.0.dist-info/METADATA,sha256=utLTydgjBJj30TfHtiO0YPYvZOp4bAysQ0jhBK8u9V8,234
+model_context_protocol_demo-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+model_context_protocol_demo-0.1.0.dist-info/entry_points.txt,sha256=N4sVKjXhgXSQo3NfQjhWtzGAyFbHHlH8LhuKm3InBBY,86
+model_context_protocol_demo-0.1.0.dist-info/top_level.txt,sha256=MV4JNeSMOA9KqkJni8mrdVdDwgCzpdvAnC6U2LTbud4,28
+model_context_protocol_demo-0.1.0.dist-info/RECORD,,

model_context_protocol_demo-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

model_context_protocol_demo-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+model_context_protocol_demo = model_context_protocol_demo.main:main

model_context_protocol_demo-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+model_context_protocol_demo