universal-cli-mcp-server 0.1.0__py3-none-any.whl

cli_mcp/executor/runner.py

@@ -0,0 +1,384 @@
+"""Subprocess execution of discovered CLI commands."""
+
+from __future__ import annotations
+
+import ctypes
+import locale
+import os
+import signal
+import subprocess
+import sys
+import time
+from collections.abc import Callable
+from contextlib import suppress
+from ctypes import wintypes
+from dataclasses import dataclass
+from pathlib import Path
+from typing import IO, Any
+
+from cli_mcp.config.settings import SecuritySettings
+from cli_mcp.detect import reject_batch_target
+from cli_mcp.errors import ExecutionError
+from cli_mcp.executor.sandbox import sandbox_argv, sandbox_available
+
+TRUNCATION_NOTE = "\n[cli-mcp: output truncated]"
+_READ_SIZE = 16_384
+_POLL_SECONDS = 0.005
+_CLEANUP_SECONDS = 0.5
+
+
+@dataclass(frozen=True)
+class ExecutionResult:
+    """What a CLI invocation produced."""
+
+    stdout: str
+    stderr: str
+    exit_code: int
+    execution_time_ms: int
+    argv: list[str]
+    sandboxed: bool = False
+    truncated: bool = False
+
+    def as_payload(self) -> dict[str, Any]:
+        """Return the JSON payload handed to MCP clients."""
+        return {
+            "stdout": self.stdout,
+            "stderr": self.stderr,
+            "exitCode": self.exit_code,
+            "executionTimeMs": self.execution_time_ms,
+            "argv": self.argv,
+            "sandboxed": self.sandboxed,
+            "truncated": self.truncated,
+        }
+
+
+def _windows_function(name: str) -> Callable[..., Any]:
+    """Resolve a platform-specific ctypes API without requiring it on POSIX."""
+    function = getattr(ctypes, name, None)
+    if not callable(function):
+        raise OSError(f"Windows ctypes API {name!r} is unavailable")
+    return lambda *args, **kwargs: function(*args, **kwargs)
+
+
+def _output_encoding() -> str:
+    """Use the Windows CLI OEM code page, or the POSIX locale encoding."""
+    if os.name == "nt":
+        return f"cp{_windows_function('WinDLL')('kernel32', use_last_error=True).GetOEMCP()}"
+    return locale.getencoding()
+
+
+class _ThreadEntry(ctypes.Structure):
+    """The documented Win32 THREADENTRY32 layout."""
+
+    _fields_ = [
+        ("dwSize", wintypes.DWORD),
+        ("cntUsage", wintypes.DWORD),
+        ("th32ThreadID", wintypes.DWORD),
+        ("th32OwnerProcessID", wintypes.DWORD),
+        ("tpBasePri", wintypes.LONG),
+        ("tpDeltaPri", wintypes.LONG),
+        ("dwFlags", wintypes.DWORD),
+    ]
+
+
+class _WindowsTree:
+    """Assign a suspended child to a job before allowing it to spawn children."""
+
+    def __init__(self, process: subprocess.Popen[bytes]) -> None:
+        # Win32 symbols are absent from POSIX ctypes and its platform-specific stubs.
+        self.api = _windows_function("WinDLL")("kernel32", use_last_error=True)
+        signatures = {
+            "CreateJobObjectW": ([ctypes.c_void_p, wintypes.LPCWSTR], wintypes.HANDLE),
+            "OpenProcess": ([wintypes.DWORD, wintypes.BOOL, wintypes.DWORD], wintypes.HANDLE),
+            "AssignProcessToJobObject": ([wintypes.HANDLE, wintypes.HANDLE], wintypes.BOOL),
+            "TerminateJobObject": ([wintypes.HANDLE, wintypes.UINT], wintypes.BOOL),
+            "CloseHandle": ([wintypes.HANDLE], wintypes.BOOL),
+            "CreateToolhelp32Snapshot": ([wintypes.DWORD, wintypes.DWORD], wintypes.HANDLE),
+            "Thread32First": ([wintypes.HANDLE, ctypes.POINTER(_ThreadEntry)], wintypes.BOOL),
+            "Thread32Next": ([wintypes.HANDLE, ctypes.POINTER(_ThreadEntry)], wintypes.BOOL),
+            "OpenThread": ([wintypes.DWORD, wintypes.BOOL, wintypes.DWORD], wintypes.HANDLE),
+            "ResumeThread": ([wintypes.HANDLE], wintypes.DWORD),
+            "PeekNamedPipe": (
+                [
+                    wintypes.HANDLE, ctypes.c_void_p, wintypes.DWORD,
+                    ctypes.c_void_p, ctypes.POINTER(wintypes.DWORD), ctypes.c_void_p,
+                ],
+                wintypes.BOOL,
+            ),
+        }
+        for name, (arguments, result) in signatures.items():
+            function = getattr(self.api, name)
+            function.argtypes = arguments
+            function.restype = result
+        self.job = self.api.CreateJobObjectW(None, None)
+        if not self.job:
+            raise _windows_error()
+        try:
+            self._assign(process.pid)
+            self._resume(process.pid)
+        except BaseException:
+            self.close()
+            raise
+
+    def _assign(self, pid: int) -> None:
+        handle = self.api.OpenProcess(0x0101, False, pid)  # SET_QUOTA | TERMINATE
+        if not handle:
+            raise _windows_error()
+        try:
+            if not self.api.AssignProcessToJobObject(self.job, handle):
+                raise _windows_error()
+        finally:
+            self.api.CloseHandle(handle)
+
+    def _resume(self, pid: int) -> None:
+        snapshot = self.api.CreateToolhelp32Snapshot(0x0004, 0)  # SNAPTHREAD
+        if snapshot == ctypes.c_void_p(-1).value:
+            raise _windows_error()
+        try:
+            entry = _ThreadEntry()
+            entry.dwSize = ctypes.sizeof(entry)
+            found = self.api.Thread32First(snapshot, ctypes.byref(entry))
+            while found:
+                if entry.th32OwnerProcessID == pid:
+                    self._resume_thread(entry.th32ThreadID)
+                    return
+                found = self.api.Thread32Next(snapshot, ctypes.byref(entry))
+            raise OSError(f"could not find suspended thread for process {pid}")
+        finally:
+            self.api.CloseHandle(snapshot)
+
+    def _resume_thread(self, tid: int) -> None:
+        handle = self.api.OpenThread(0x0002, False, tid)  # SUSPEND_RESUME
+        if not handle:
+            raise _windows_error()
+        try:
+            if self.api.ResumeThread(handle) == 0xFFFFFFFF:
+                raise _windows_error()
+        finally:
+            self.api.CloseHandle(handle)
+
+    def stop(self) -> None:
+        """Terminate only processes belonging to this invocation's job."""
+        if not self.api.TerminateJobObject(self.job, 1):
+            raise _windows_error()
+
+    def close(self) -> None:
+        """Terminate any remaining descendants and release the job handle."""
+        try:
+            self.stop()
+        finally:
+            self.api.CloseHandle(self.job)
+
+
+def _windows_error(code: int | None = None) -> OSError:
+    """Construct the native Windows error without importing Win32-only symbols on POSIX."""
+    if code is None:
+        code = int(_windows_function("get_last_error")())
+    error = _windows_function("WinError")(code)
+    if not isinstance(error, OSError):
+        raise TypeError("ctypes.WinError did not return an OSError")
+    return error
+
+
+class _PipeCapture:
+    """Retain a byte prefix while continuously discarding excess pipe output."""
+
+    def __init__(self, stream: IO[bytes], limit: int, tree: _WindowsTree | None) -> None:
+        self.stream = stream
+        self.fd = stream.fileno()
+        self.limit = limit
+        self.tree = tree
+        self.data = bytearray()
+        self.truncated = False
+        self.finished = False
+        if tree is None:
+            os.set_blocking(self.fd, False)
+
+    def read(self) -> bool:
+        """Consume one bounded chunk without waiting for data or pipe closure."""
+        if self.finished:
+            return False
+        size = _READ_SIZE
+        if self.tree is not None:
+            import msvcrt
+
+            get_osfhandle = getattr(msvcrt, "get_osfhandle", None)
+            if not callable(get_osfhandle):
+                raise OSError("Windows msvcrt.get_osfhandle API is unavailable")
+            available = wintypes.DWORD()
+            if not self.tree.api.PeekNamedPipe(
+                get_osfhandle(self.fd), None, 0, None, ctypes.byref(available), None,
+            ):
+                error = int(_windows_function("get_last_error")())
+                if error in (109, 232):  # BROKEN_PIPE / NO_DATA
+                    self.finished = True
+                    return False
+                raise _windows_error(error)
+            if not available.value:
+                return False
+            size = min(size, available.value)
+        try:
+            chunk = os.read(self.fd, size)
+        except BlockingIOError:
+            return False
+        if not chunk:
+            self.finished = True
+            return False
+        remaining = self.limit - len(self.data)
+        self.data.extend(chunk[:remaining])
+        self.truncated |= len(chunk) > remaining
+        return True
+
+    def text(self, encoding: str) -> str:
+        """Prefer strict UTF-8, then the CLI encoding with visible byte escapes."""
+        try:
+            text = self.data.decode("utf-8", errors="strict")
+        except UnicodeDecodeError:
+            text = self.data.decode(encoding, errors="backslashreplace")
+        text = text.replace("\r\n", "\n").replace("\r", "\n")
+        return text + TRUNCATION_NOTE if self.truncated else text
+
+
+def _capture_until(pipes: list[_PipeCapture], deadline: float) -> bool:
+    """Drain both streams fairly until EOF or the monotonic deadline."""
+    while not all(pipe.finished for pipe in pipes):
+        if time.perf_counter() >= deadline:
+            return False
+        progressed = False
+        for pipe in pipes:
+            progressed |= pipe.read()
+        if not progressed:
+            time.sleep(min(_POLL_SECONDS, max(0.0, deadline - time.perf_counter())))
+    return True
+
+
+def _stop_process(process: subprocess.Popen[bytes], tree: _WindowsTree | None) -> None:
+    """Kill the invocation's job/session, never processes selected by name."""
+    if tree is not None:
+        tree.stop()
+    elif sys.platform != "win32":
+        with suppress(ProcessLookupError):
+            os.killpg(process.pid, signal.SIGKILL)
+    elif process.poll() is None:
+        process.kill()
+
+
+def _finish_process(process: subprocess.Popen[bytes], tree: _WindowsTree | None) -> None:
+    """Bound reaping and close pipes without reader threads or blocking joins."""
+    try:
+        if tree is not None:
+            tree.close()
+        elif process.returncode is None:
+            # Do not signal a reaped POSIX PID/group: its ID could be reused.
+            _stop_process(process, tree)
+    finally:
+        for stream in (process.stdout, process.stderr):
+            if stream is not None:
+                stream.close()
+        try:
+            process.wait(timeout=_CLEANUP_SECONDS)
+        except subprocess.TimeoutExpired as exc:
+            raise ExecutionError(f"could not reap process {process.pid} after termination") from exc
+
+
+def _collect_output(
+    process: subprocess.Popen[bytes],
+    tree: _WindowsTree | None,
+    security: SecuritySettings,
+    started: float,
+    encoding: str,
+) -> tuple[str, str, int, bool]:
+    """Collect bounded streams and handle the shared process/pipe deadline."""
+    assert process.stdout is not None
+    assert process.stderr is not None
+    pipes = [
+        _PipeCapture(process.stdout, security.max_output_bytes, tree),
+        _PipeCapture(process.stderr, security.max_output_bytes, tree),
+    ]
+    deadline = started + security.timeout_seconds
+    captured = _capture_until(pipes, deadline)
+    timed_out = not captured
+    if captured:
+        try:
+            process.wait(timeout=max(0.0, deadline - time.perf_counter()))
+        except subprocess.TimeoutExpired:
+            timed_out = True
+    if timed_out:
+        _stop_process(process, tree)
+        _capture_until(pipes, time.perf_counter() + _CLEANUP_SECONDS)
+        for pipe in pipes:
+            pipe.truncated |= not pipe.finished
+    stdout, stderr = (pipe.text(encoding) for pipe in pipes)
+    if timed_out:
+        stderr += f"\n[cli-mcp] timed out after {security.timeout_seconds}s"
+    exit_code = -1 if timed_out else process.returncode
+    assert exit_code is not None
+    return stdout, stderr, exit_code, any(pipe.truncated for pipe in pipes)
+
+
+def run(
+    argv: list[str],
+    security: SecuritySettings,
+    cwd: Path | None = None,
+    *,
+    env: dict[str, str] | None = None,
+) -> ExecutionResult:
+    """Run *argv* with bounded raw-byte capture per stream, including timeouts.
+
+    Diagnostic/truncation notes are outside the byte budget. Decoding tries
+    strict UTF-8, then Windows OEM/POSIX locale with visible backslash escapes
+    for undecodable bytes, not silent loss or a reader-thread exception.
+    Descendants holding inherited pipes count toward the same timeout; remaining
+    job/session members are terminated on timeout. Windows job members are also
+    terminated after successful exit; already-reaped POSIX IDs are not signaled.
+    """
+    reject_batch_target(argv[0])
+    sandboxed = security.sandbox is not None
+    if sandboxed and security.sandbox is not None:
+        if not sandbox_available(security.sandbox.backend):
+            raise ExecutionError(
+                f"sandbox backend {security.sandbox.backend!r} is not available. "
+                "Install it, or set security.sandbox.backend to podman."
+            )
+        argv_to_run = sandbox_argv(argv, security.sandbox, cwd)
+    else:
+        argv_to_run = list(argv)
+
+    started = time.perf_counter()
+    process: subprocess.Popen[bytes] | None = None
+    tree: _WindowsTree | None = None
+    try:
+        encoding = _output_encoding()
+        process = subprocess.Popen(
+            argv_to_run,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=False,
+            bufsize=0,
+            cwd=str(cwd) if cwd else None,
+            env=env,
+            start_new_session=os.name != "nt",
+            creationflags=0x0004 if os.name == "nt" else 0,  # CREATE_SUSPENDED
+        )
+        if os.name == "nt":
+            tree = _WindowsTree(process)
+        stdout, stderr, exit_code, truncated = _collect_output(process, tree, security, started, encoding)
+    except OSError as exc:
+        raise ExecutionError(f"could not run {argv_to_run[0]!r}: {exc}") from exc
+    finally:
+        if process is not None:
+            try:
+                _finish_process(process, tree)
+            except OSError as exc:
+                raise ExecutionError(f"could not clean up {argv_to_run[0]!r}: {exc}") from exc
+
+    elapsed_ms = int((time.perf_counter() - started) * 1000)
+    return ExecutionResult(
+        stdout=stdout,
+        stderr=stderr,
+        exit_code=exit_code,
+        execution_time_ms=elapsed_ms,
+        argv=argv_to_run,
+        sandboxed=sandboxed,
+        truncated=truncated,
+    )

cli_mcp/executor/sandbox.py

@@ -0,0 +1,31 @@
+"""Container sandboxing for CLI execution.
+
+The CLI binary itself runs inside a container started by docker or podman, so a
+misconfigured tool cannot touch the host. The chosen image must contain the CLI;
+for image-less workflows the image can be built to bundle it.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from cli_mcp.config.settings import SandboxSettings
+
+
+def sandbox_argv(argv: list[str], sandbox: SandboxSettings, cwd: Path | None = None) -> list[str]:
+    """Wrap *argv* in a ``docker``/``podman`` run invocation."""
+    prefix = [sandbox.backend, "run", "--rm"]
+    if not sandbox.network:
+        prefix.append("--network=none")
+    if sandbox.workdir_mount and cwd is not None:
+        prefix.extend(["--workdir", sandbox.container_workdir, "-v", f"{cwd}:{sandbox.container_workdir}"])
+    prefix.extend(sandbox.extra_args)
+    prefix.append(sandbox.image)
+    return [*prefix, *argv]
+
+
+def sandbox_available(backend: str) -> bool:
+    """Whether the container backend binary is on PATH."""
+    import shutil
+
+    return shutil.which(backend) is not None

cli_mcp/mcp/__init__.py

@@ -0,0 +1,22 @@
+"""MCP layer: tool adapters and server construction."""
+
+from __future__ import annotations
+
+from cli_mcp.mcp.server import build_server, publish_schema, tool_definitions, tool_schemas
+from cli_mcp.mcp.tool_adapter import (
+    ToolDefinition,
+    build_docs_tool,
+    build_tool,
+    docs_tool_name,
+)
+
+__all__ = [
+    "ToolDefinition",
+    "build_docs_tool",
+    "build_server",
+    "build_tool",
+    "docs_tool_name",
+    "publish_schema",
+    "tool_definitions",
+    "tool_schemas",
+]

cli_mcp/mcp/server.py

@@ -0,0 +1,80 @@
+"""Build a fully MCP-compliant server from discovered commands."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from mcp.server.mcpserver import MCPServer
+
+from cli_mcp.config.settings import Settings
+from cli_mcp.detect import launch_for
+from cli_mcp.errors import SchemaError
+from cli_mcp.executor.approval import ApprovalGate
+from cli_mcp.mcp.tool_adapter import ToolDefinition, build_docs_tool, build_tool, docs_tool_name
+from cli_mcp.models import DiscoveryResult
+from cli_mcp.schema.docgen import render_docs
+from cli_mcp.security.policy import AccessPolicy
+
+
+def tool_definitions(settings: Settings, result: DiscoveryResult, cwd: Path | None = None) -> list[ToolDefinition]:
+    """Tool definitions for *result*, usable for exports without a server."""
+    policy = AccessPolicy(settings.security)
+    policy.authorize_binary(settings.binary)
+    resolved = result.resolved_path or settings.binary
+    launch = launch_for(resolved)
+    gate = ApprovalGate(settings.security)
+    definitions = [build_tool(spec, launch, settings, policy, gate, cwd) for spec in result.commands]
+    if settings.mcp.include_docs_tool:
+        definitions.append(build_docs_tool(render_docs(result, settings.mcp), docs_tool_name(resolved)))
+    return definitions
+
+
+def build_server(
+    settings: Settings,
+    result: DiscoveryResult,
+    cwd: Path | None = None,
+    gate: ApprovalGate | None = None,
+) -> MCPServer:
+    """Create an MCP server that publishes every discovered command as a tool."""
+    policy = AccessPolicy(settings.security)
+    policy.authorize_binary(settings.binary)
+    resolved = result.resolved_path or settings.binary
+    launch = launch_for(resolved)
+    approval_gate = gate or ApprovalGate(settings.security)
+    server = MCPServer(
+        name=settings.server_name,
+        title=settings.mcp.title,
+        description=settings.mcp.description,
+        instructions=settings.mcp.instructions,
+        version=settings.mcp.version,
+    )
+    for spec in result.commands:
+        tool = build_tool(spec, launch, settings, policy, approval_gate, cwd)
+        server.add_tool(tool.handler, name=tool.name, description=tool.description)
+        publish_schema(server, tool.name, tool.schema)
+    if settings.mcp.include_docs_tool:
+        docs_tool = build_docs_tool(render_docs(result, settings.mcp), docs_tool_name(resolved))
+        server.add_tool(docs_tool.handler, name=docs_tool.name, description=docs_tool.description)
+        publish_schema(server, docs_tool.name, docs_tool.schema)
+    return server
+
+
+def publish_schema(server: MCPServer, name: str, schema: dict[str, Any]) -> None:
+    """Replace the SDK-derived input schema with cli-mcp's exact schema.
+
+    The SDK derives schemas from the handler signature; cli-mcp synthesises that
+    signature from the discovered metadata, and then pins the published schema so
+    descriptions, enums and defaults survive exactly as discovered.
+    """
+    manager = server._tool_manager
+    tool = manager.get_tool(name)
+    if tool is None:
+        raise SchemaError(f"tool {name!r} is not published on the server")
+    tool.parameters = schema
+
+
+def tool_schemas(server: MCPServer) -> dict[str, dict[str, Any]]:
+    """Return the published input schemas by tool name, used by ``cli-mcp export-schema``."""
+    manager = server._tool_manager
+    return {tool.name: dict(tool.parameters) for tool in manager.list_tools()}

cli_mcp/mcp/tool_adapter.py

@@ -0,0 +1,120 @@
+"""Adapting a discovered command into an MCP tool with a faithful input schema."""
+
+from __future__ import annotations
+
+import asyncio
+import inspect
+import json
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Annotated, Any
+
+from pydantic import WithJsonSchema
+
+from cli_mcp.config.settings import Settings
+from cli_mcp.detect import executable_stem
+from cli_mcp.errors import SecurityViolation
+from cli_mcp.executor.approval import ApprovalGate
+from cli_mcp.executor.argv import build_argv
+from cli_mcp.executor.runner import run
+from cli_mcp.models import CommandSpec
+from cli_mcp.schema.jsonschema import input_schema
+from cli_mcp.schema.validate import validate_arguments
+from cli_mcp.security.policy import AccessPolicy
+
+
+@dataclass(frozen=True)
+class ToolDefinition:
+    """One MCP tool: name, description, exact input schema and async handler."""
+
+    name: str
+    description: str
+    schema: dict[str, Any]
+    handler: Callable[..., Awaitable[str]]
+
+
+def tool_description(spec: CommandSpec, binary: str, policy: AccessPolicy) -> str:
+    """Tool description: what the command does plus its security status."""
+    parts = [spec.description or f"Run {spec.invocation(binary)}"]
+    parts.append(f"Runs the CLI command `{spec.invocation(binary)}`.")
+    if spec.destructive or policy.assess(binary, spec).destructive:
+        parts.append("This command is considered destructive and needs approval before it runs.")
+    if spec.examples:
+        parts.append("Example: " + spec.examples[0])
+    return " ".join(parts)
+
+
+def build_tool(
+    spec: CommandSpec,
+    launch: list[str],
+    settings: Settings,
+    policy: AccessPolicy,
+    gate: ApprovalGate,
+    cwd: Path | None = None,
+) -> ToolDefinition:
+    """Build an MCP tool for one discovered command.
+
+    *launch* is the command that runs the CLI: an interpreter prefix when the
+    target is a script, otherwise the resolved binary path.
+    """
+    schema = input_schema(spec)
+    published = dict(schema)
+    published["properties"] = dict(published.get("properties", {}))
+    published["additionalProperties"] = False
+
+    async def handler(**arguments: Any) -> str:
+        """Validate, gate and run the command, returning the execution payload as JSON."""
+        validated = validate_arguments(spec, arguments)
+        argv = build_argv(launch, spec, validated)
+        decision = policy.evaluate(settings.binary, spec, argv)
+        if not decision.allowed:
+            raise SecurityViolation(decision.reason or "command rejected by security policy")
+        gate.approve(spec.name, argv, decision)
+        result = await asyncio.to_thread(run, argv, settings.security, cwd or settings.execution.cwd)
+        return json.dumps(result.as_payload())
+
+    handler.__doc__ = published.get("description") or spec.description
+    handler.__signature__ = _signature(published)  # type: ignore[attr-defined]
+    description = tool_description(spec, settings.binary, policy)
+    return ToolDefinition(name=spec.name, description=description, schema=published, handler=handler)
+
+
+def _signature(schema: dict[str, Any]) -> inspect.Signature:
+    """Keyword-only signature whose JSON Schema matches *schema* exactly."""
+    parameters: list[inspect.Parameter] = []
+    for name, definition in schema.get("properties", {}).items():
+        annotation = Annotated[Any, WithJsonSchema(definition)]
+        required = name in schema.get("required", [])
+        default = inspect.Parameter.empty if required else None
+        parameters.append(
+            inspect.Parameter(name, inspect.Parameter.KEYWORD_ONLY, default=default, annotation=annotation)
+        )
+    return inspect.Signature(parameters, return_annotation=str)
+
+
+def docs_tool_name(binary: str) -> str:
+    """Name of the generated documentation tool."""
+    from cli_mcp.models import sanitize_tool_name
+
+    stem = executable_stem(binary) or binary
+    return sanitize_tool_name(f"{stem}_docs")
+
+
+def build_docs_tool(docs: str, name: str) -> ToolDefinition:
+    """Build a tool that returns the generated Markdown documentation for the CLI."""
+
+    async def handler() -> str:
+        """Return the generated documentation."""
+        return docs
+
+    handler.__signature__ = inspect.Signature([], return_annotation=str)  # type: ignore[attr-defined]
+    description = (
+        "Documentation for this CLI: list every tool, its arguments and example invocations before running commands."
+    )
+    return ToolDefinition(
+        name=name,
+        description=description,
+        schema={"type": "object", "properties": {}, "additionalProperties": False},
+        handler=handler,
+    )