feat: add [--host] parameter for streamable-http mode.

luoshasha · luoshasha · commit b2b0cb027f83 · 2025-11-26T09:58:12.000+08:00
diff --git a/mcp_run_python/_cli.py b/mcp_run_python/_cli.py
@@ -20,7 +20,8 @@ def cli_logic(args_list: Sequence[str] | None = None) -> int:
         description=f'mcp-run-python CLI v{__version__}\n\nMCP server for running untrusted Python code.\n',
         formatter_class=argparse.RawTextHelpFormatter,
     )
-
+    parser.add_argument('--host', type=str, default='127.0.0.1',
+                        help='Host to bind the HTTP server to (default: 127.0.0.1). Use 0.0.0.0 to bind to all interfaces, e.g. when using Docker.')
     parser.add_argument('--port', type=int, help='Port to run the server on, default 3001.')
     parser.add_argument('--deps', '--dependencies', help='Comma separated list of dependencies to install')
     parser.add_argument(
@@ -51,6 +52,7 @@ def cli_logic(args_list: Sequence[str] | None = None) -> int:
             args.mode.replace('-', '_'),
             allow_networking=not args.disable_networking,
             http_port=args.port,
+            http_host=args.host,
             dependencies=deps,
             deps_log_handler=deps_log_handler,
             verbose=bool(args.verbose),
diff --git a/mcp_run_python/deno/src/main.ts b/mcp_run_python/deno/src/main.ts
@@ -30,11 +30,13 @@ export async function main() {
       return
     } else if (args[0] === 'streamable_http') {
       const port = parseInt(flags.port)
-      runStreamableHttp(port, deps, flags['return-mode'], false)
+      const host = flags.host
+      runStreamableHttp(port, host, deps, flags['return-mode'], false)
       return
     } else if (args[0] === 'streamable_http_stateless') {
       const port = parseInt(flags.port)
-      runStreamableHttp(port, deps, flags['return-mode'], true)
+      const host = flags.host
+      runStreamableHttp(port, host, deps, flags['return-mode'], true)
       return
     } else if (args[0] === 'example') {
       await example(deps)
@@ -52,6 +54,7 @@ Usage: deno ... deno/main.ts [stdio|streamable_http|streamable_http_stateless|in
 
 options:
 --port <port>             Port to run the HTTP server on (default: 3001)
+--host <host>             Host to run the HTTP server on (default: 127.0.0.1)
 --deps <deps>             Comma separated list of dependencies to install
 --return-mode <xml/json>  Return mode for output data (default: xml)`,
   )
@@ -171,9 +174,9 @@ function httpSetJsonResponse(res: http.ServerResponse, status: number, text: str
 /*
  * Run the MCP server using the Streamable HTTP transport
  */
-function runStreamableHttp(port: number, deps: string[], returnMode: string, stateless: boolean): void {
+function runStreamableHttp(port: number, host:string, deps: string[], returnMode: string, stateless: boolean): void {
   const server = (stateless ? createStatelessHttpServer : createStatefulHttpServer)(deps, returnMode)
-  server.listen(port, () => {
+  server.listen(port, host, () => {
     console.log(`Listening on port ${port}`)
   })
 }
@@ -353,4 +356,4 @@ const LogLevels: LoggingLevel[] = [
   'emergency',
 ]
 
-await main()
+await main()
diff --git a/mcp_run_python/main.py b/mcp_run_python/main.py
@@ -11,7 +11,7 @@
 from pathlib import Path
 from typing import Literal, ParamSpec, TypeVar, cast
 
-__all__ = 'run_mcp_server', 'DenoEnv', 'prepare_deno_env', 'async_prepare_deno_env'
+__all__ = "run_mcp_server", "DenoEnv", "prepare_deno_env", "async_prepare_deno_env"
 
 logger = logging.getLogger(__name__)
 LoggingLevel = Literal['debug', 'info', 'notice', 'warning', 'error', 'critical', 'alert', 'emergency']
@@ -23,8 +23,9 @@ def run_mcp_server(
     mode: Mode,
     *,
     http_port: int | None = None,
+    http_host: str | None = None,
     dependencies: list[str] | None = None,
-    return_mode: Literal['json', 'xml'] = 'xml',
+    return_mode: Literal["json", "xml"] = "xml",
     deps_log_handler: LogHandler | None = None,
     allow_networking: bool = True,
     verbose: bool = False,
@@ -34,6 +35,7 @@ def run_mcp_server(
     Args:
         mode: The mode to run the server in.
         http_port: The port to run the server on if mode is `streamable_http`.
+        http_host: The host to run the server on if mode is `streamable_http`.
         dependencies: The dependencies to install.
         return_mode: The mode to return tool results in.
         deps_log_handler: Optional function to receive logs emitted while installing dependencies.
@@ -49,19 +51,22 @@ def run_mcp_server(
         mode,
         dependencies=dependencies,
         http_port=http_port,
+        http_host=http_host,
         return_mode=return_mode,
         deps_log_handler=deps_log_handler,
         allow_networking=allow_networking,
     ) as env:
         if mode in ('streamable_http', 'streamable_http_stateless'):
             logger.info('Running mcp-run-python via %s on port %d...', mode, http_port)
         else:
-            logger.info('Running mcp-run-python via %s...', mode)
+            logger.info("Running mcp-run-python via %s...", mode)
 
         try:
-            p = subprocess.run(('deno', *env.args), cwd=env.cwd, stdout=stdout, stderr=stderr)
+            p = subprocess.run(
+                ("deno", *env.args), cwd=env.cwd, stdout=stdout, stderr=stderr
+            )
         except KeyboardInterrupt:  # pragma: no cover
-            logger.warning('Server stopped.')
+            logger.warning("Server stopped.")
             return 0
         else:
             return p.returncode
@@ -78,8 +83,9 @@ def prepare_deno_env(
     mode: Mode,
     *,
     http_port: int | None = None,
+    http_host: str | None = None,
     dependencies: list[str] | None = None,
-    return_mode: Literal['json', 'xml'] = 'xml',
+    return_mode: Literal["json", "xml"] = "xml",
     deps_log_handler: LogHandler | None = None,
     allow_networking: bool = True,
 ) -> Iterator[DenoEnv]:
@@ -92,6 +98,7 @@ def prepare_deno_env(
     Args:
         mode: The mode to run the server in.
         http_port: The port to run the server on if mode is `streamable_http`.
+        http_host: The host to run the server on if mode is `streamable_http`.
         dependencies: The dependencies to install.
         return_mode: The mode to return tool results in.
         deps_log_handler: Optional function to receive logs emitted while installing dependencies.
@@ -101,22 +108,22 @@ def prepare_deno_env(
     Returns:
         Yields the deno environment details.
     """
-    cwd = Path(tempfile.mkdtemp()) / 'mcp-run-python'
+    cwd = Path(tempfile.mkdtemp()) / "mcp-run-python"
     try:
-        src = Path(__file__).parent / 'deno'
-        logger.debug('Copying from %s to %s...', src, cwd)
+        src = Path(__file__).parent / "deno"
+        logger.debug("Copying from %s to %s...", src, cwd)
         shutil.copytree(src, cwd)
-        logger.info('Installing dependencies %s...', dependencies)
+        logger.info("Installing dependencies %s...", dependencies)
 
-        args = 'deno', *_deno_install_args(dependencies)
+        args = "deno", *_deno_install_args(dependencies)
         p = subprocess.Popen(args, cwd=cwd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
         stdout: list[str] = []
         if p.stdout is not None:
             for line in p.stdout:
                 line = line.strip()
                 if deps_log_handler:
-                    parts = line.split('|', 1)
-                    level, msg = parts if len(parts) == 2 else ('info', line)
+                    parts = line.split("|", 1)
+                    level, msg = parts if len(parts) == 2 else ("info", line)
                     deps_log_handler(cast(LoggingLevel, level), msg)
                 stdout.append(line)
         p.wait()
@@ -126,6 +133,7 @@ def prepare_deno_env(
         args = _deno_run_args(
             mode,
             http_port=http_port,
+            http_host=http_host,
             dependencies=dependencies,
             return_mode=return_mode,
             allow_networking=allow_networking,
@@ -141,8 +149,9 @@ async def async_prepare_deno_env(
     mode: Mode,
     *,
     http_port: int | None = None,
+    http_host: str | None = None,
     dependencies: list[str] | None = None,
-    return_mode: Literal['json', 'xml'] = 'xml',
+    return_mode: Literal["json", "xml"] = "xml",
     deps_log_handler: LogHandler | None = None,
     allow_networking: bool = True,
 ) -> AsyncIterator[DenoEnv]:
@@ -151,6 +160,7 @@ async def async_prepare_deno_env(
         prepare_deno_env,
         mode,
         http_port=http_port,
+        http_host=http_host,
         dependencies=dependencies,
         return_mode=return_mode,
         deps_log_handler=deps_log_handler,
@@ -164,13 +174,13 @@ async def async_prepare_deno_env(
 
 def _deno_install_args(dependencies: list[str] | None = None) -> list[str]:
     args = [
-        'run',
-        '--allow-net',
-        '--allow-read=./node_modules',
-        '--allow-write=./node_modules',
-        '--node-modules-dir=auto',
-        'src/main.ts',
-        'noop',
+        "run",
+        "--allow-net",
+        "--allow-read=./node_modules",
+        "--allow-write=./node_modules",
+        "--node-modules-dir=auto",
+        "src/main.ts",
+        "noop",
     ]
     if dependencies is not None:
         args.append(f'--deps={",".join(dependencies)}')
@@ -181,32 +191,35 @@ def _deno_run_args(
     mode: Mode,
     *,
     http_port: int | None = None,
+    http_host: str | None = None,
     dependencies: list[str] | None = None,
-    return_mode: Literal['json', 'xml'] = 'xml',
+    return_mode: Literal["json", "xml"] = "xml",
     allow_networking: bool = True,
 ) -> list[str]:
-    args = ['run']
+    args = ["run"]
     if allow_networking:
-        args += ['--allow-net']
+        args += ["--allow-net"]
     args += [
-        '--allow-read=./node_modules',
-        '--node-modules-dir=auto',
-        'src/main.ts',
+        "--allow-read=./node_modules",
+        "--node-modules-dir=auto",
+        "src/main.ts",
         mode,
-        f'--return-mode={return_mode}',
+        f"--return-mode={return_mode}",
     ]
     if dependencies is not None:
         args.append(f'--deps={",".join(dependencies)}')
-    if http_port is not None:
-        if mode in ('streamable_http', 'streamable_http_stateless'):
-            args.append(f'--port={http_port}')
-        else:
-            raise ValueError('Port is only supported for `streamable_http` modes')
+    if mode in ('streamable_http', 'streamable_http_stateless'):
+        if http_port is not None:
+            args.append(f"--port={http_port}")
+        if http_host is not None:
+            args.append(f"--host={http_host}")
+    elif http_port is not None or http_host is not None:
+        raise ValueError("Port and host are only supported for `streamable_http` mode")
     return args
 
 
-P = ParamSpec('P')
-T = TypeVar('T')
+P = ParamSpec("P")
+T = TypeVar("T")
 
 
 async def _asyncify(func: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
