allow multiple sandboxes, rename methods (#3)

Author: samuelcolvin

.gitignore

@@ -13,4 +13,4 @@ env*/
 .coverage*
 /test_tmp/
 
-/mcp_run_python/deno/prepareEnvCode.ts
+/mcp_run_python/deno/src/prepareEnvCode.ts

.pre-commit-config.yaml

@@ -44,6 +44,13 @@ repos:
         language: system
         types: [python]
         pass_filenames: false
+      - id: lint-py
+        name: lint python
+        entry: make
+        args: [lint-py]
+        language: system
+        types: [python]
+        pass_filenames: false
       - id: typecheck-py
         name: typecheck python
         entry: make

Makefile

@@ -23,7 +23,7 @@ build: ## Build mcp_run_python/deno/prepareEnvCode.ts
 
 .PHONY: format-ts
 format-ts: ## Format TS code
-	cd mcp_run_python && deno task format
+	cd mcp_run_python/deno && deno task format
 
 .PHONY: format-py
 format-py: ## Format Python code
@@ -35,7 +35,7 @@ format: format-ts format-py ## Format all code
 
 .PHONY: lint-ts
 lint-ts: ## Lint TS code
-	cd mcp_run_python && deno task lint
+	cd mcp_run_python/deno && deno task lint
 
 .PHONY: lint-py
 lint-py: ## Lint Python code
@@ -47,7 +47,7 @@ lint:  lint-ts lint-py ## Lint all code
 
 .PHONY: typecheck-ts
 typecheck-ts: build ## Typecheck TS code
-	cd mcp_run_python && deno task typecheck
+	cd mcp_run_python/deno && deno task typecheck
 
 .PHONY: typecheck-py
 typecheck-py: ## Typecheck the code

README.md

@@ -49,13 +49,7 @@ where:
 - `example` will run a minimal Python script using `numpy`, useful for checking that the package is working, for the code
   to run successfully, you'll need to install `numpy` using `uvx mcp-run-python --deps numpy example`
 
-## Usage in codes as an MCP server
-
-```bash
-pip install mcp-run-python
-# or
-uv add mcp-run-python
-```
+## Usage with Pydantic AI
 
 Then you can use `mcp-run-python` with Pydantic AI:
 
@@ -70,7 +64,7 @@ logfire.configure()
 logfire.instrument_mcp()
 logfire.instrument_pydantic_ai()
 
-server = MCPServerStdio('deno', args=deno_args_prepare('stdio'))
+server = MCPServerStdio('uvx', args=['mcp-run-python@latest', 'stdio'], timeout=10)
 agent = Agent('claude-3-5-haiku-latest', toolsets=[server])
 
 
@@ -85,9 +79,48 @@ if __name__ == '__main__':
     asyncio.run(main())
 ```
 
-**Note**: `deno_args_prepare` can take `deps` as a keyword argument to install dependencies.
-As well as returning the args needed to run `mcp_run_python`, `deno_args_prepare` installs the dependencies
-so they can be used by the server.
+## Usage in codes as an MCP server
+
+First install the `mcp-run-python` package:
+
+```bash
+pip install mcp-run-python
+# or
+uv add mcp-run-python
+```
+
+With `mcp-run-python` installed, you can also run deno directly with `prepare_deno_env` or `async_prepare_deno_env`
+
+
+```python
+from pydantic_ai import Agent
+from pydantic_ai.mcp import MCPServerStdio
+from mcp_run_python import async_prepare_deno_env
+
+import logfire
+
+logfire.configure()
+logfire.instrument_mcp()
+logfire.instrument_pydantic_ai()
+
+
+async def main():
+    async with async_prepare_deno_env('stdio') as deno_env:
+        server = MCPServerStdio('deno', args=deno_env.args, cwd=deno_env.cwd, timeout=10)
+        agent = Agent('claude-3-5-haiku-latest', toolsets=[server])
+        async with agent:
+            result = await agent.run('How many days between 2000-01-01 and 2025-03-18?')
+        print(result.output)
+        #> There are 9,208 days between January 1, 2000, and March 18, 2025.w
+
+if __name__ == '__main__':
+    import asyncio
+    asyncio.run(main())
+```
+
+**Note**: `prepare_deno_env` can take `deps` as a keyword argument to install dependencies.
+As well as returning the args needed to run `mcp_run_python`, `prepare_deno_env` creates a new deno environment
+and installs the dependencies so they can be used by the server.
 
 ## Usage in code with `code_sandbox`
 

build/build.py

@@ -8,7 +8,7 @@
 
 # Define source and destination paths
 src = this_dir / 'prepare_env.py'
-dst = root_dir / 'mcp_run_python' / 'deno' / 'prepareEnvCode.ts'
+dst = root_dir / 'mcp_run_python' / 'deno' / 'src' / 'prepareEnvCode.ts'
 
 python_code = src.read_text()
 

examples/direct.py

@@ -1,29 +1,30 @@
 from mcp import ClientSession, StdioServerParameters
 from mcp.client.stdio import stdio_client
 
-from mcp_run_python import deno_args_prepare
+from mcp_run_python import async_prepare_deno_env
 
 code = """
 import numpy
 a = numpy.array([1, 2, 3])
 print(a)
 a
 """
-server_params = StdioServerParameters(command='deno', args=deno_args_prepare('stdio', deps=['numpy']))
 
 
 async def main():
-    async with stdio_client(server_params) as (read, write):
-        async with ClientSession(read, write) as session:
-            await session.initialize()
-            tools = await session.list_tools()
-            print(len(tools.tools))
-            print(repr(tools.tools[0].name))
-            print(repr(tools.tools[0].inputSchema))
-            result = await session.call_tool('run_python_code', {'python_code': code})
-            content_block = result.content[0]
-            assert content_block.type == 'text'
-            print(content_block.text)
+    async with async_prepare_deno_env('stdio', dependencies=['numpy']) as deno_env:
+        server_params = StdioServerParameters(command='deno', args=deno_env.args, cwd=deno_env.cwd)
+        async with stdio_client(server_params) as (read, write):
+            async with ClientSession(read, write) as session:
+                await session.initialize()
+                tools = await session.list_tools()
+                print(len(tools.tools))
+                print(repr(tools.tools[0].name))
+                print(repr(tools.tools[0].inputSchema))
+                result = await session.call_tool('run_python_code', {'python_code': code})
+                content_block = result.content[0]
+                assert content_block.type == 'text'
+                print(content_block.text)
 
 
 if __name__ == '__main__':

examples/pydantic_ai_ex.py

@@ -1,9 +1,8 @@
 from pydantic_ai import Agent
 from pydantic_ai.mcp import MCPServerStdio
 
-from mcp_run_python import deno_args_prepare
-
-server = MCPServerStdio('deno', args=deno_args_prepare('stdio'))
+server = MCPServerStdio('uv', args=['run', 'mcp-run-python', 'stdio'], timeout=10)
+# server = MCPServerStdio('uvx', args=['mcp-run-python@latest', 'stdio'], timeout=10)
 agent_with_python = Agent('claude-3-5-haiku-latest', toolsets=[server])
 
 

examples/sandbox.py

@@ -1,7 +1,7 @@
 from mcp_run_python import code_sandbox
 
 
-def print_wait(level: str, message: str):
+def log_handler(level: str, message: str):
     print(f'{level}: {message}')
 
 
@@ -14,7 +14,8 @@ def print_wait(level: str, message: str):
 
 
 async def main():
-    async with code_sandbox(dependencies=['numpy'], print_handler=print_wait) as sandbox:
+    async with code_sandbox(dependencies=['numpy'], log_handler=log_handler, logging_level='debug') as sandbox:
+        print('running code')
         result = await sandbox.eval(code)
         print(f'{result["status"].title()}:')
         if result['status'] == 'success':

mcp_run_python/__init__.py

@@ -3,7 +3,7 @@
 from importlib.metadata import version as _metadata_version
 
 from .code_sandbox import code_sandbox
-from .main import deno_args_prepare, deno_run_server
+from .main import async_prepare_deno_env, prepare_deno_env, run_mcp_server
 
 __version__ = _metadata_version('mcp_run_python')
-__all__ = '__version__', 'deno_args_prepare', 'deno_run_server', 'code_sandbox'
+__all__ = '__version__', 'prepare_deno_env', 'run_mcp_server', 'code_sandbox', 'async_prepare_deno_env'

mcp_run_python/_cli.py

@@ -1,23 +1,30 @@
 from __future__ import annotations as _annotations
 
 import argparse
+import logging
+import sys
 from collections.abc import Sequence
 
 from . import __version__
-from .main import deno_run_server
+from .main import LoggingLevel, run_mcp_server
 
 
-def cli(args_list: Sequence[str] | None = None):  # pragma: no cover
+def cli():
+    sys.exit(cli_logic())
+
+
+def cli_logic(args_list: Sequence[str] | None = None) -> int:
     """Run the CLI."""
     parser = argparse.ArgumentParser(
         prog='mcp-run-python',
         description=f'mcp-run-python CLI v{__version__}\n\nMCP server for running untrusted Python code.\n',
         formatter_class=argparse.RawTextHelpFormatter,
     )
-    parser.add_argument('--version', action='store_true', help='Show version and exit')
 
     parser.add_argument('--port', type=int, help='Port to run the server on, default 3001.')
-    parser.add_argument('--deps', help='Comma separated list of dependencies to install')
+    parser.add_argument('--deps', '--dependencies', help='Comma separated list of dependencies to install')
+    parser.add_argument('--verbose', action='store_true', help='Enable verbose logging')
+    parser.add_argument('--version', action='store_true', help='Show version and exit')
     parser.add_argument(
         'mode',
         choices=['stdio', 'streamable-http', 'example'],
@@ -28,8 +35,33 @@ def cli(args_list: Sequence[str] | None = None):  # pragma: no cover
     args = parser.parse_args(args_list)
     if args.version:
         print(f'mcp-run-python {__version__}')
+        return 0
     elif args.mode:
+        logging.basicConfig(
+            level=logging.DEBUG if args.verbose else logging.INFO,
+            stream=sys.stderr,
+            format='%(message)s',
+        )
+
         deps: list[str] = args.deps.split(',') if args.deps else []
-        deno_run_server(args.mode.replace('-', '_'), port=args.port, deps=deps, prep_log_handler=print)
+        return_code = run_mcp_server(
+            args.mode.replace('-', '_'),
+            http_port=args.port,
+            dependencies=deps,
+            deps_log_handler=deps_log_handler,
+        )
+        return return_code
     else:
         parser.error('Mode is required')
+
+
+logger = logging.getLogger('mcp-run-python-install')
+
+
+def deps_log_handler(level: LoggingLevel, msg: str):
+    if level == 'debug':
+        logger.debug('install: %s', msg)
+    elif level == 'info':
+        logger.info('install: %s', msg)
+    else:
+        logger.warning('install: %s', msg)