mcp-python-exec-sandbox 0.1.0__tar.gz → 0.1.2__tar.gz

mcp_python_exec_sandbox-0.1.2/.github/workflows/ci.yml

@@ -0,0 +1,25 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v4
+      - run: uv sync --dev
+      - run: uv run ruff check .
+      - run: uv run ruff format --check .
+
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v4
+      - run: uv sync --dev
+      - run: uv run pytest tests/ -v

{mcp_python_exec_sandbox-0.1.0 → mcp_python_exec_sandbox-0.1.2}/CLAUDE.md

@@ -37,7 +37,7 @@ uv run pytest e2e_tests/ -v  # E2E tests (slow, needs network)
 
 - Run `uv run pytest tests/ -v` before committing. All tests must pass.
 - Keep dependencies minimal. Do not add runtime deps without strong justification.
-- No type checkers or linters are configured. Keep code straightforward and readable.
+- Lint with `uv run ruff check .` and format with `uv run ruff format --check .` before committing. Fix issues with `--fix` / `ruff format .`.
 - Tool docstrings in `server.py` are user-facing — they become the MCP tool descriptions that agents see. Write them for an LLM audience: include examples, avoid unexplained jargon, link PEPs.
 - Always pin versions in examples (e.g. `"pandas>=2.2"` not `"pandas"`).
 - Sandbox backends must degrade gracefully: if the tool (bwrap, sandbox-exec, docker) is missing, fall back to `NoopSandbox` with a warning.

mcp_python_exec_sandbox-0.1.2/PKG-INFO

@@ -0,0 +1,307 @@
+Metadata-Version: 2.4
+Name: mcp-python-exec-sandbox
+Version: 0.1.2
+Summary: MCP server for secure Python script execution with automatic dependency management
+Project-URL: Homepage, https://github.com/lu-zhengda/mcp-python-exec-sandbox
+Project-URL: Repository, https://github.com/lu-zhengda/mcp-python-exec-sandbox
+Project-URL: Issues, https://github.com/lu-zhengda/mcp-python-exec-sandbox/issues
+Author: Zhengda Lu
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agent,ai,execution,mcp,python,sandbox
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Interpreters
+Requires-Python: >=3.13
+Requires-Dist: fastmcp<3,>=2.0
+Requires-Dist: tomli-w>=1.0
+Description-Content-Type: text/markdown
+
+# mcp-python-exec-sandbox
+
+Sandboxed Python execution for AI agents. Scripts run in ephemeral, isolated environments with inline dependencies ([PEP 723](https://peps.python.org/pep-0723/)) -- **zero host pollution, zero leftover venvs, zero package conflicts**.
+
+## Why?
+
+Every coding agent can already run Python on your host. The problem is what happens next: packages accumulate, venvs sprawl, and a rogue `pip install` breaks your system. **mcp-python-exec-sandbox** eliminates this:
+
+- Scripts execute in a sandbox (bubblewrap on Linux, sandbox-exec on macOS, Docker everywhere)
+- Dependencies are declared inline and resolved ephemerally via `uv`
+- Nothing touches your host's Python, site-packages, or virtualenvs
+- Each execution is isolated and disposable
+
+## Features
+
+- **Sandboxed execution** -- platform-specific isolation prevents host filesystem access
+- **PEP 723 inline metadata** -- declare dependencies directly in scripts with `# /// script` blocks
+- **Multi-version Python** -- run scripts on Python 3.13, 3.14, or 3.15 (uv downloads the right version automatically)
+- **Ephemeral environments** -- dependencies are resolved per-execution, never persisted
+- **Package caching** -- uv's global cache makes repeat installs near-instant
+- **Timeout enforcement** -- configurable per-execution timeouts
+- **Output truncation** -- prevents runaway output from overwhelming the agent
+
+## Prerequisites
+
+All setups require:
+
+- **Python 3.13+** -- to run the MCP server process
+- **[uv](https://docs.astral.sh/uv/getting-started/installation/)** -- manages script execution, dependency resolution, and Python version downloads. Also provides `uvx` for running the server without installing it globally.
+
+Additional requirements depend on your chosen sandbox backend:
+
+| Setup | Additional requirements | Install |
+|-------|------------------------|---------|
+| **Native sandbox (Linux)** | [bubblewrap](https://github.com/containers/bubblewrap) | `sudo apt install bubblewrap` |
+| **Native sandbox (macOS)** | None -- `sandbox-exec` is built into macOS | -- |
+| **Docker sandbox** | [Docker Engine](https://docs.docker.com/engine/install/) | See Docker docs |
+| **No sandbox** | None | -- |
+
+> **Host Python vs. execution Python:** These are independent. Python 3.13+ is needed to run the server process itself. The `--python-version` flag controls which Python version your *scripts* execute on -- uv downloads the target version automatically. You do not need to install Python 3.14 or 3.15 on your host to run scripts on those versions.
+
+## Quick start
+
+### Claude Code (native sandbox -- recommended)
+
+```bash
+claude mcp add python-sandbox -- uvx mcp-python-exec-sandbox --sandbox-backend native
+```
+
+### Claude Code (Docker sandbox)
+
+```bash
+docker build -t mcp-python-exec-sandbox profiles/
+claude mcp add python-sandbox -- uvx mcp-python-exec-sandbox --sandbox-backend docker
+```
+
+> The Docker image build requires the repo source. Clone it first: `git clone https://github.com/lu-zhengda/mcp-python-exec-sandbox.git`
+
+### Claude Code (no sandbox)
+
+```bash
+claude mcp add python-sandbox -- uvx mcp-python-exec-sandbox --sandbox-backend none
+```
+
+### Manual JSON config
+
+```json
+{
+  "mcpServers": {
+    "python-sandbox": {
+      "command": "uvx",
+      "args": ["mcp-python-exec-sandbox", "--sandbox-backend", "native"]
+    }
+  }
+}
+```
+
+## Multi-version Python
+
+Use `--python-version` to target a specific Python version. uv downloads it automatically -- no manual install needed.
+
+```bash
+# Python 3.13 (default)
+uvx mcp-python-exec-sandbox --python-version 3.13
+
+# Python 3.14
+uvx mcp-python-exec-sandbox --python-version 3.14
+
+# Python 3.15
+uvx mcp-python-exec-sandbox --python-version 3.15
+```
+
+This works across all sandbox backends. The Docker sandbox uses uv inside the container to manage Python versions, so the same `--python-version` flag applies.
+
+## Tools
+
+### `execute_python`
+
+Execute a Python script with automatic dependency management.
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `script` | str | required | Python source code, may include PEP 723 inline metadata |
+| `dependencies` | list[str] | `[]` | Extra PEP 508 dependency specifiers to merge |
+| `timeout_seconds` | int | 30 | Maximum execution time (1--300) |
+
+```python
+# Simple script
+execute_python(script="print('hello world')")
+
+# Script with dependencies
+execute_python(
+    script="import requests; print(requests.get('https://httpbin.org/get').status_code)",
+    dependencies=["requests"]
+)
+
+# Script with inline PEP 723 metadata
+execute_python(script="""
+# /// script
+# dependencies = ["pandas", "matplotlib"]
+# ///
+
+import pandas as pd
+print(pd.DataFrame({'a': [1,2,3]}).describe())
+""")
+```
+
+### `check_environment`
+
+Returns information about the execution environment: Python version, uv version, platform, sandbox status, and configuration.
+
+### `validate_script`
+
+Validates a script's PEP 723 metadata and dependencies without executing it.
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `script` | str | required | Python source code to validate |
+| `dependencies` | list[str] | `[]` | Extra dependency specifiers to validate |
+
+## Sandbox backends
+
+| Backend | Platform | Tool | Notes |
+|---------|----------|------|-------|
+| `native` | Linux | bubblewrap | Namespace isolation, network allowed |
+| `native` | macOS | sandbox-exec | Seatbelt profiles, network allowed |
+| `docker` | Any | Docker | Container isolation, resource limits |
+| `none` | Any | -- | No sandboxing (not recommended) |
+
+If the requested sandbox tool is unavailable, the server falls back to `none` with a warning.
+
+### Docker sandbox setup
+
+```bash
+docker build -t mcp-python-exec-sandbox profiles/
+```
+
+## CLI options
+
+```
+mcp-python-exec-sandbox [OPTIONS]
+
+Options:
+  --python-version TEXT     Python version for execution (default: 3.13)
+  --sandbox-backend TEXT    native | docker | none (default: native)
+  --max-timeout INT         Maximum allowed timeout in seconds (default: 300)
+  --default-timeout INT     Default timeout in seconds (default: 30)
+  --max-output-bytes INT    Maximum output size in bytes (default: 102400)
+  --no-warm-cache           Skip cache warming on startup
+  --uv-path TEXT            Path to uv binary (default: uv)
+```
+
+## Development
+
+### Setup
+
+```bash
+git clone https://github.com/lu-zhengda/mcp-python-exec-sandbox.git
+cd mcp-python-exec-sandbox
+uv sync --dev
+```
+
+### Project structure
+
+```
+src/mcp_python_exec_sandbox/   # Package source
+  server.py               # FastMCP server + tool definitions
+  executor.py             # uv subprocess orchestration
+  script.py               # PEP 723 metadata parsing/merging
+  sandbox.py              # Sandbox ABC + factory
+  sandbox_{linux,macos,docker}.py
+  config.py, cache.py, output.py, errors.py
+tests/                    # Unit + integration tests (mocked or local uv)
+e2e_tests/                # End-to-end tests (require uv + network)
+profiles/                 # Dockerfile, macOS seatbelt profile, warmup packages
+.devcontainer/            # Devcontainer for Linux sandbox testing from macOS
+```
+
+### Running tests
+
+**Unit and integration tests** -- fast, run everywhere:
+
+```bash
+uv run pytest tests/ -v
+```
+
+**E2E tests** -- require `uv` and network access. These exercise real script execution, package installation, MCP protocol flow, and sandbox enforcement:
+
+```bash
+uv run pytest e2e_tests/ -v
+```
+
+### Docker sandbox tests
+
+The Docker E2E tests (`e2e_tests/test_docker_sandbox.py`) verify execution, dependency installation, read-only filesystem enforcement, host isolation, and timeout handling through the Docker backend.
+
+Prerequisites:
+
+1. Docker must be installed and running
+2. Build the sandbox image:
+
+```bash
+docker build -t mcp-python-exec-sandbox profiles/
+```
+
+Then run:
+
+```bash
+uv run pytest e2e_tests/test_docker_sandbox.py -v
+```
+
+These tests are automatically skipped if Docker is unavailable or the image hasn't been built.
+
+### Linux sandbox tests (devcontainer)
+
+The Linux sandbox tests (`e2e_tests/test_sandbox_enforcement.py::test_linux_sandbox_blocks_etc_shadow`) use bubblewrap (`bwrap`) for namespace isolation. They are skipped on macOS because `bwrap` is Linux-only.
+
+To run them from macOS, use the included devcontainer which provides Ubuntu 24.04 with `bwrap` pre-installed:
+
+**VS Code:**
+
+1. Install the [Dev Containers](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers) extension
+2. Open the project and select **Reopen in Container**
+3. In the integrated terminal:
+
+```bash
+uv run pytest e2e_tests/test_sandbox_enforcement.py -v
+```
+
+**CLI:**
+
+```bash
+# Install the devcontainer CLI (once)
+npm install -g @devcontainers/cli
+
+# Build and start the container
+devcontainer up --workspace-folder .
+
+# Run the Linux sandbox tests inside the container
+devcontainer exec --workspace-folder . uv run pytest e2e_tests/test_sandbox_enforcement.py -v
+```
+
+### Test matrix
+
+| Test suite | Command | Requirements |
+|------------|---------|-------------|
+| Unit tests | `uv run pytest tests/ -v` | `uv` |
+| Integration tests | `uv run pytest tests/test_integration.py -v` | `uv` |
+| E2E (general) | `uv run pytest e2e_tests/ -v` | `uv`, network |
+| E2E (Docker sandbox) | `uv run pytest e2e_tests/test_docker_sandbox.py -v` | `uv`, Docker, sandbox image |
+| E2E (Linux/bwrap sandbox) | `uv run pytest e2e_tests/test_sandbox_enforcement.py -v` | `uv`, Linux with `bwrap` (or devcontainer) |
+
+### Contributing
+
+- One logical change per commit. Descriptive commit message (imperative mood).
+- Run `uv run pytest tests/ -v` before committing -- all tests must pass.
+- Add tests for new functionality: unit tests in `tests/`, E2E in `e2e_tests/` if it needs real execution.
+- Keep dependencies minimal. Do not add runtime deps without strong justification.
+- Tool docstrings in `server.py` are user-facing MCP tool descriptions. Write them for an LLM audience.
+- Sandbox backends must degrade gracefully: if the tool is missing, fall back to `NoopSandbox` with a warning.
+
+## License
+
+MIT

{mcp_python_exec_sandbox-0.1.0 → mcp_python_exec_sandbox-0.1.2}/e2e_tests/test_data_science.py

@@ -94,7 +94,9 @@ print("=== Top Products ===")
 for prod, rev in top.items():
     print(f"  {prod}: {rev:.2f}")
 
-pivot = df.pivot_table(values="revenue", index="product", columns="region", aggfunc="mean").round(2)
+pivot = df.pivot_table(
+    values="revenue", index="product", columns="region", aggfunc="mean"
+).round(2)
 print("\\n=== Pivot ===")
 print(pivot.to_string())
 """,
@@ -313,7 +315,9 @@ dist = np.random.uniform(1, 30, n)
 
 price = 150*sqft + 20000*bedrooms - 1000*age - 2000*dist + 50000 + np.random.normal(0, 20000, n)
 
-df = pd.DataFrame({"sqft": sqft, "bedrooms": bedrooms, "age": age, "distance": dist, "price": price})
+df = pd.DataFrame({
+    "sqft": sqft, "bedrooms": bedrooms, "age": age, "distance": dist, "price": price
+})
 features = ["sqft", "bedrooms", "age", "distance"]
 X, y = df[features].values, df["price"].values
 
@@ -527,7 +531,7 @@ class TestPEP723InlineMetadata:
     @pytest.mark.asyncio
     async def test_httpx_pydantic_inline(self):
         """Script with inline PEP 723 block declaring httpx + pydantic."""
-        script = '''\
+        script = """\
 # /// script
 # dependencies = ["httpx", "pydantic>=2.0"]
 # requires-python = ">=3.11"
@@ -543,7 +547,7 @@ resp = httpx.get("https://httpbin.org/ip")
 info = IPInfo.model_validate(resp.json())
 print(f"status: {resp.status_code}")
 print(f"ip: {info.origin}")
-'''
+"""
         with tempfile.TemporaryDirectory(prefix="mcp-e2e-") as tmpdir:
             path = Path(tmpdir) / "script.py"
             path.write_text(script, encoding="utf-8")

{mcp_python_exec_sandbox-0.1.0 → mcp_python_exec_sandbox-0.1.2}/e2e_tests/test_docker_sandbox.py

@@ -17,7 +17,9 @@ def _docker_available() -> bool:
         return False
     try:
         result = subprocess.run(
-            [docker, "info"], capture_output=True, timeout=5,
+            [docker, "info"],
+            capture_output=True,
+            timeout=5,
         )
         return result.returncode == 0
     except (subprocess.TimeoutExpired, OSError):
@@ -31,7 +33,8 @@ def _docker_image_exists(name: str = "mcp-python-exec-sandbox") -> bool:
     try:
         result = subprocess.run(
             [docker, "image", "inspect", name],
-            capture_output=True, timeout=10,
+            capture_output=True,
+            timeout=10,
         )
         return result.returncode == 0
     except (subprocess.TimeoutExpired, OSError):
@@ -49,7 +52,8 @@ pytestmark = [
     ),
     pytest.mark.skipif(
         not _docker_image_exists(),
-        reason="mcp-python-exec-sandbox image not built (run: docker build -t mcp-python-exec-sandbox profiles/)",
+        reason="mcp-python-exec-sandbox image not built "
+        "(run: docker build -t mcp-python-exec-sandbox profiles/)",
     ),
 ]
 
@@ -186,6 +190,7 @@ print(f"ETC_HOSTNAME={etc_hostname}")
 
     # The container gets its own hostname (Docker assigns a short hex id)
     import socket
+
     host_hostname = socket.gethostname()
     # Extract container hostname from output
     for line in result.stdout.splitlines():

{mcp_python_exec_sandbox-0.1.0 → mcp_python_exec_sandbox-0.1.2}/e2e_tests/test_mcp_protocol.py

@@ -13,8 +13,11 @@ pytestmark = pytest.mark.skipif(
 )
 
 _SERVER_CMD = [
-    sys.executable, "-m", "mcp_python_exec_sandbox",
-    "--sandbox-backend", "none",
+    sys.executable,
+    "-m",
+    "mcp_python_exec_sandbox",
+    "--sandbox-backend",
+    "none",
     "--no-warm-cache",
 ]
 
@@ -54,11 +57,14 @@ class MCPClient:
         return json.loads(line)
 
     def initialize(self):
-        result = self.send("initialize", {
-            "protocolVersion": "2024-11-05",
-            "capabilities": {},
-            "clientInfo": {"name": "test", "version": "1.0"},
-        })
+        result = self.send(
+            "initialize",
+            {
+                "protocolVersion": "2024-11-05",
+                "capabilities": {},
+                "clientInfo": {"name": "test", "version": "1.0"},
+            },
+        )
         self.send("notifications/initialized", {}, notify=True)
         return result
 
@@ -125,35 +131,44 @@ class TestMCPProtocol:
 
     def test_execute_simple_script(self, mcp):
         """Test executing a simple print script."""
-        result = mcp.call_tool("execute_python", {
-            "script": "print('hello from mcp')",
-        })
+        result = mcp.call_tool(
+            "execute_python",
+            {
+                "script": "print('hello from mcp')",
+            },
+        )
         text = result["result"]["content"][0]["text"]
         assert "hello from mcp" in text
         assert "exit_code: 0" in text
 
     def test_execute_with_deps(self, mcp):
         """Test executing a script with dependencies."""
-        result = mcp.call_tool("execute_python", {
-            "script": "import pydantic; print(f'v{pydantic.__version__}')",
-            "dependencies": ["pydantic>=2.0"],
-            "timeout_seconds": 120,
-        })
+        result = mcp.call_tool(
+            "execute_python",
+            {
+                "script": "import pydantic; print(f'v{pydantic.__version__}')",
+                "dependencies": ["pydantic>=2.0"],
+                "timeout_seconds": 120,
+            },
+        )
         text = result["result"]["content"][0]["text"]
         assert "exit_code: 0" in text
         assert "v2." in text
 
     def test_execute_pandas(self, mcp):
         """Test executing a pandas script via MCP."""
-        result = mcp.call_tool("execute_python", {
-            "script": (
-                "import pandas as pd; "
-                "df = pd.DataFrame({'a': [1,2,3], 'b': [4,5,6]}); "
-                "print(df.sum().to_dict())"
-            ),
-            "dependencies": ["pandas"],
-            "timeout_seconds": 120,
-        })
+        result = mcp.call_tool(
+            "execute_python",
+            {
+                "script": (
+                    "import pandas as pd; "
+                    "df = pd.DataFrame({'a': [1,2,3], 'b': [4,5,6]}); "
+                    "print(df.sum().to_dict())"
+                ),
+                "dependencies": ["pandas"],
+                "timeout_seconds": 120,
+            },
+        )
         text = result["result"]["content"][0]["text"]
         assert "exit_code: 0" in text
         assert "'a': 6" in text
@@ -161,16 +176,19 @@ class TestMCPProtocol:
 
     def test_execute_numpy_scipy(self, mcp):
         """Test numpy + scipy through MCP."""
-        result = mcp.call_tool("execute_python", {
-            "script": (
-                "import numpy as np; from scipy import stats; "
-                "np.random.seed(42); "
-                "r, p = stats.pearsonr(np.random.randn(100), np.random.randn(100)); "
-                "print(f'r={r:.4f}')"
-            ),
-            "dependencies": ["numpy", "scipy"],
-            "timeout_seconds": 120,
-        })
+        result = mcp.call_tool(
+            "execute_python",
+            {
+                "script": (
+                    "import numpy as np; from scipy import stats; "
+                    "np.random.seed(42); "
+                    "r, p = stats.pearsonr(np.random.randn(100), np.random.randn(100)); "
+                    "print(f'r={r:.4f}')"
+                ),
+                "dependencies": ["numpy", "scipy"],
+                "timeout_seconds": 120,
+            },
+        )
         text = result["result"]["content"][0]["text"]
         assert "exit_code: 0" in text
         assert "r=" in text
@@ -178,11 +196,11 @@ class TestMCPProtocol:
     def test_execute_with_pep723_inline(self, mcp):
         """Test a script with inline PEP 723 metadata block."""
         script = (
-            '# /// script\n'
+            "# /// script\n"
             '# dependencies = ["rich"]\n'
-            '# ///\n'
-            '\n'
-            'from rich.text import Text\n'
+            "# ///\n"
+            "\n"
+            "from rich.text import Text\n"
             'print(Text("hello").plain)\n'
         )
         result = mcp.call_tool("execute_python", {"script": script, "timeout_seconds": 120})
@@ -192,28 +210,37 @@ class TestMCPProtocol:
 
     def test_execute_timeout(self, mcp):
         """Test that timeout is enforced."""
-        result = mcp.call_tool("execute_python", {
-            "script": "import time; time.sleep(60)",
-            "timeout_seconds": 2,
-        })
+        result = mcp.call_tool(
+            "execute_python",
+            {
+                "script": "import time; time.sleep(60)",
+                "timeout_seconds": 2,
+            },
+        )
         text = result["result"]["content"][0]["text"]
         assert "timed_out: true" in text
 
     def test_execute_nonzero_exit(self, mcp):
         """Test script that exits with non-zero code."""
-        result = mcp.call_tool("execute_python", {
-            "script": "import sys; print('bye'); sys.exit(1)",
-        })
+        result = mcp.call_tool(
+            "execute_python",
+            {
+                "script": "import sys; print('bye'); sys.exit(1)",
+            },
+        )
         text = result["result"]["content"][0]["text"]
         assert "exit_code: 1" in text
         assert "bye" in text
 
     def test_validate_script_valid(self, mcp):
         """Test validate_script with valid deps."""
-        result = mcp.call_tool("validate_script", {
-            "script": "import pandas",
-            "dependencies": ["pandas>=2.0", "numpy"],
-        })
+        result = mcp.call_tool(
+            "validate_script",
+            {
+                "script": "import pandas",
+                "dependencies": ["pandas>=2.0", "numpy"],
+            },
+        )
         text = result["result"]["content"][0]["text"]
         assert "VALID" in text
         assert "pandas>=2.0" in text
@@ -221,9 +248,12 @@ class TestMCPProtocol:
 
     def test_validate_script_no_deps(self, mcp):
         """Test validate_script with a bare script."""
-        result = mcp.call_tool("validate_script", {
-            "script": "print('hello')",
-        })
+        result = mcp.call_tool(
+            "validate_script",
+            {
+                "script": "print('hello')",
+            },
+        )
         text = result["result"]["content"][0]["text"]
         assert "VALID" in text
         assert "dependencies: none" in text
@@ -231,12 +261,12 @@ class TestMCPProtocol:
     def test_validate_script_inline_metadata(self, mcp):
         """Test validate_script with inline PEP 723 metadata."""
         script = (
-            '# /// script\n'
+            "# /// script\n"
             '# dependencies = ["requests"]\n'
             '# requires-python = ">=3.11"\n'
-            '# ///\n'
-            '\n'
-            'import requests\n'
+            "# ///\n"
+            "\n"
+            "import requests\n"
         )
         result = mcp.call_tool("validate_script", {"script": script})
         text = result["result"]["content"][0]["text"]

{mcp_python_exec_sandbox-0.1.0 → mcp_python_exec_sandbox-0.1.2}/e2e_tests/test_package_install.py

@@ -47,7 +47,7 @@ print(resp.status_code)
 @pytest.mark.asyncio
 async def test_inline_metadata_in_script():
     """Test that scripts with inline PEP 723 metadata work."""
-    script = '''\
+    script = """\
 # /// script
 # dependencies = ["rich"]
 # requires-python = ">=3.11"
@@ -56,7 +56,7 @@ async def test_inline_metadata_in_script():
 from rich.text import Text
 t = Text("hello")
 print(t.plain)
-'''
+"""
 
     with tempfile.TemporaryDirectory(prefix="mcp-e2e-") as tmpdir:
         script_path = Path(tmpdir) / "test.py"

{mcp_python_exec_sandbox-0.1.0 → mcp_python_exec_sandbox-0.1.2}/e2e_tests/test_real_execution.py

@@ -1,6 +1,5 @@
 """E2E tests — require uv + network."""
 
-import asyncio
 import shutil
 import tempfile
 from pathlib import Path