mcpsync-cli 0.1.0__py3-none-any.whl

mcpsync/__init__.py

@@ -0,0 +1,31 @@
+"""``mcpsync`` — Synchronous MCP Python client.
+
+Call MCP servers from sync Python without ``async``/``await``. Wraps the
+official `mcp` SDK's async ``ClientSession`` inside a dedicated
+``asyncio.Runner`` per session, and exposes ``call_tool``, ``list_tools``,
+``call_resource``, and ``list_resources`` as plain blocking methods.
+
+Example::
+
+    from mcpsync import SyncMCPClient, StdioServerParameters
+
+    params = StdioServerParameters(command="python", args=["-m", "my_server"])
+    with SyncMCPClient(params) as client:
+        tools = client.list_tools()
+        result = client.call_tool("git_log", {"n": 5})
+"""
+
+from mcpsync.client import SyncMCPClient
+from mcpsync.errors import MCPError
+from mcpsync.params import HttpServerParameters, StdioServerParameters
+from mcpsync.sync import sync
+
+__all__ = [
+    "HttpServerParameters",
+    "MCPError",
+    "StdioServerParameters",
+    "SyncMCPClient",
+    "sync",
+]
+
+__version__ = "0.1.0"

mcpsync/__init__.pyi

@@ -0,0 +1,64 @@
+"""Type stubs for the ``mcpsync`` public API."""
+
+from collections.abc import Callable, Mapping
+from types import TracebackType
+from typing import Any, ParamSpec, TypeVar
+
+from typing_extensions import Self
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+class StdioServerParameters:
+    command: str
+    args: tuple[str, ...]
+    env: Mapping[str, str] | None
+    cwd: str | None
+    def __init__(
+        self,
+        command: str,
+        args: tuple[str, ...] | list[str] = (),
+        env: Mapping[str, str] | None = None,
+        cwd: str | None = None,
+    ) -> None: ...
+    def to_argv(self) -> list[str]: ...
+
+class HttpServerParameters:
+    url: str
+    headers: Mapping[str, str]
+    timeout: float
+    def __init__(
+        self,
+        url: str,
+        headers: Mapping[str, str] | None = None,
+        timeout: float = 30.0,
+    ) -> None: ...
+
+class MCPError(Exception):
+    code: int
+    message: str
+    data: Any
+    def __init__(self, code: int, message: str, data: Any = None) -> None: ...
+
+class SyncMCPClient:
+    def __init__(
+        self,
+        params: StdioServerParameters | HttpServerParameters,
+        *,
+        timeout: float | None = None,
+    ) -> None: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None: ...
+    def list_tools(self) -> list[Any]: ...
+    def call_tool(self, name: str, arguments: dict[str, Any] | None = None) -> Any: ...
+    def list_resources(self) -> list[Any]: ...
+    def call_resource(self, uri: str) -> Any: ...
+    def read_resource(self, uri: str) -> Any: ...
+    def close(self) -> None: ...
+
+def sync(fn: Callable[P, Any]) -> Callable[P, Any]: ...

mcpsync/__main__.py

@@ -0,0 +1,5 @@
+"""Allow ``python -m mcpsync`` to invoke the CLI."""
+
+from mcpsync.cli import main
+
+raise SystemExit(main())

mcpsync/cli.py

@@ -0,0 +1,330 @@
+"""``mcpsync`` CLI — inspect and drive MCP servers from the command line.
+
+Two top-level transports (``stdio`` / ``http``) each with sub-actions
+(``list-tools``, ``list-resources``, ``call-tool <name> [json-args]``,
+``call-resource <uri>``). For the stdio transport the server argv
+comes after a ``--`` separator. Output is always JSON on stdout;
+non-zero exit on errors so the CLI is pipe-friendly.
+
+Usage examples::
+
+    mcpsync stdio list-tools -- python -m my_server
+    mcpsync stdio call-tool echo '{"msg":"hi"}' -- python -m my_server
+    mcpsync http list-tools --url http://localhost:8000/mcp
+    mcpsync http call-resource file:///data.json --url http://x/mcp
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from typing import Any, Sequence
+
+from mcpsync import (
+    HttpServerParameters,
+    StdioServerParameters,
+    SyncMCPClient,
+    __version__,
+)
+
+_PROG = "mcpsync"
+
+
+# ---------------------------------------------------------------------- #
+# Argparse setup
+# ---------------------------------------------------------------------- #
+
+
+class _SplitOnDashDash(argparse.Action):
+    """Custom action: consume remaining argv, splitting on the first ``--``.
+
+    Before this action runs, the parser has already consumed transport
+    options (``--cwd``, ``--env``, ``--url``, ``--header``, ...). The
+    action parser then set the ``action`` + its sub-args. After all of
+    that, the remaining argv is the server argv for stdio, and must
+    come after an explicit ``--`` separator.
+    """
+
+    def __call__(self, parser, namespace, values, option_string=None):  # noqa: D401
+        # argparse passes `values` from the `nargs='*'` position; we ignore
+        # and use sys.argv ourselves, starting from the action's index.
+        # Instead, use the namespace's `_rest` which we set in main().
+        argv = getattr(parser, "_mcpsync_pending_argv", None)
+        if argv is None:
+            argv = sys.argv[1:]
+        try:
+            idx = argv.index("--")
+        except ValueError:
+            setattr(namespace, self.dest, [])
+            return
+        setattr(namespace, self.dest, argv[idx + 1 :])
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog=_PROG,
+        description=(
+            "Synchronous MCP client — connect to an MCP server (stdio or HTTP) "
+            "and run read-only commands (list-tools, list-resources, call-tool, "
+            "call-resource) without writing async code."
+        ),
+    )
+    p.add_argument("--version", action="version", version=f"{_PROG} {__version__}")
+    sub = p.add_subparsers(dest="command", required=True)
+
+    # stdio ----------------------------------------------------------------
+    stdio = sub.add_parser(
+        "stdio",
+        help="Spawn a stdio MCP server and run a command against it.",
+        description=(
+            "Spawns a local MCP server (everything after `--` is its argv) "
+            "and runs a command (list-tools, call-tool, list-resources, "
+            "call-resource) against it."
+        ),
+    )
+    stdio.add_argument("--cwd", default=None, help="Working directory for the spawned server.")
+    stdio.add_argument(
+        "--env",
+        action="append",
+        default=[],
+        metavar="KEY=VAL",
+        help="Extra env var to pass to the server. Repeatable.",
+    )
+    _add_action_subparsers(stdio)
+    # NOTE: the stdio server argv is NOT a positional here. We split
+    # on the `--` separator in `main()` and attach the server argv
+    # to the namespace as `args.server_argv`. If we declared a
+    # REMAINDER positional, argparse would eat the action's first
+    # token (e.g. `list-tools`).
+
+    # http -----------------------------------------------------------------
+    http = sub.add_parser(
+        "http",
+        help="Connect to a streamable-HTTP MCP server and run a command.",
+        description=(
+            "Connects to a streamable-HTTP MCP server (e.g. "
+            "`http://localhost:8000/mcp`) and runs a command."
+        ),
+    )
+    http.add_argument("--url", required=True, help="Server URL, including scheme.")
+    http.add_argument(
+        "--header",
+        action="append",
+        default=[],
+        metavar="KEY=VAL",
+        help="HTTP header to send. Repeatable.",
+    )
+    http.add_argument(
+        "--timeout",
+        type=float,
+        default=30.0,
+        help="Request timeout in seconds (default 30).",
+    )
+    _add_action_subparsers(http)
+
+    return p
+
+
+def _add_action_subparsers(parent: argparse.ArgumentParser) -> None:
+    """Add the four action subcommands to a parent transport parser.
+
+    The order matters: actions must be added BEFORE any positional
+    like stdio's ``server_argv_after`` (REMAINDER), otherwise REMAINDER
+    swallows the action's first token.
+    """
+    actions = parent.add_subparsers(dest="action", required=True)
+
+    actions.add_parser("list-tools", help="List the server's tools as JSON.")
+    actions.add_parser("list-resources", help="List the server's resources as JSON.")
+
+    ct = actions.add_parser("call-tool", help="Call a named tool (optional JSON args).")
+    ct.add_argument("name", help="Tool name.")
+    ct.add_argument(
+        "args",
+        nargs="?",
+        default=None,
+        help="JSON object of arguments (defaults to none).",
+    )
+
+    cr = actions.add_parser("call-resource", help="Read a resource by URI.")
+    cr.add_argument("uri", help="Resource URI.")
+
+
+# ---------------------------------------------------------------------- #
+# Dispatch
+# ---------------------------------------------------------------------- #
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = _build_parser()
+    # Argparse's REMAINDER happily eats everything after a positional
+    # action (e.g. `list-tools`). We need to know where the action
+    # ended in the raw argv so we can split the `--` from the server
+    # argv. Strategy: do a *pre-pass* to find the first `--`; everything
+    # before it is parsed by argparse (so the action subparser gets
+    # `list-tools` / `call-tool echo '{"a":1}'` etc.), and everything
+    # after the `--` is the server argv.
+    if argv is None:
+        argv = sys.argv[1:]
+    try:
+        sep_idx = argv.index("--")
+    except ValueError:
+        sep_idx = len(argv)
+    pre = argv[:sep_idx]
+    post = argv[sep_idx + 1 :]  # server argv (may be empty)
+    try:
+        args = parser.parse_args(pre)
+    except SystemExit as e:
+        return int(e.code) if isinstance(e.code, int) else 2
+    # Attach the server argv to the namespace if this is stdio.
+    if args.command == "stdio":
+        args.server_argv = post
+    else:
+        # For http, anything after `--` is an error (no server argv).
+        if post:
+            print(
+                f"mcpsync: http subcommand does not accept a `--` server argv "
+                f"(got: {' '.join(post)!r})",
+                file=sys.stderr,
+            )
+            return 2
+    try:
+        if args.command == "stdio":
+            return _cmd_stdio(args)
+        if args.command == "http":
+            return _cmd_http(args)
+    except KeyboardInterrupt:
+        return 130
+    return 2
+
+
+def _cmd_stdio(args: argparse.Namespace) -> int:
+    argv = args.server_argv
+    if not argv:
+        print("mcpsync: stdio subcommand needs a server argv after `--`", file=sys.stderr)
+        return 2
+    command, *rest = argv
+    try:
+        env = _parse_kv_list(args.env, flag="--env")
+    except SystemExit as e:
+        return int(e.code) if isinstance(e.code, int) else 2
+    params = StdioServerParameters(
+        command=command, args=tuple(rest), env=env or None, cwd=args.cwd
+    )
+    return _run_action(params, args.action, args)
+
+
+def _cmd_http(args: argparse.Namespace) -> int:
+    try:
+        headers = _parse_kv_list(args.header, flag="--header")
+    except SystemExit as e:
+        return int(e.code) if isinstance(e.code, int) else 2
+    params = HttpServerParameters(url=args.url, headers=headers, timeout=args.timeout)
+    return _run_action(params, args.action, args)
+
+
+def _run_action(
+    params: StdioServerParameters | HttpServerParameters,
+    action: str,
+    args: argparse.Namespace,
+) -> int:
+    with SyncMCPClient(params) as client:
+        if action == "list-tools":
+            tools = client.list_tools()
+            print(json.dumps([_tool_to_dict(t) for t in tools], indent=2))
+            return 0
+        if action == "list-resources":
+            resources = client.list_resources()
+            print(json.dumps([_resource_to_dict(r) for r in resources], indent=2))
+            return 0
+        if action == "call-tool":
+            raw = getattr(args, "args", None)
+            if raw is None:
+                arguments = None
+            else:
+                try:
+                    arguments = json.loads(raw)
+                except json.JSONDecodeError as exc:
+                    print(f"mcpsync: invalid JSON arguments: {exc}", file=sys.stderr)
+                    return 2
+            result = client.call_tool(args.name, arguments)
+            print(json.dumps(_result_to_dict(result), indent=2))
+            return 0
+        if action == "call-resource":
+            result = client.call_resource(args.uri)
+            print(json.dumps(_result_to_dict(result), indent=2))
+            return 0
+    return 2  # unreachable
+
+
+# ---------------------------------------------------------------------- #
+# Serialization helpers
+# ---------------------------------------------------------------------- #
+
+
+def _parse_kv_list(pairs: list[str], flag: str) -> dict[str, str]:
+    out: dict[str, str] = {}
+    for p in pairs:
+        if "=" not in p:
+            print(f"mcpsync: {flag} must be KEY=VAL (got {p!r})", file=sys.stderr)
+            raise SystemExit(2)
+        k, v = p.split("=", 1)
+        if not k:
+            print(f"mcpsync: {flag} has empty key (got {p!r})", file=sys.stderr)
+            raise SystemExit(2)
+        out[k] = v
+    return out
+
+
+def _tool_to_dict(tool: Any) -> dict[str, Any]:
+    return {
+        "name": getattr(tool, "name", ""),
+        "description": getattr(tool, "description", ""),
+        # mcp 2.0 renamed inputSchema -> input_schema; accept either.
+        "inputSchema": (
+            getattr(tool, "inputSchema", None)
+            or getattr(tool, "input_schema", None)
+            or {}
+        ),
+    }
+
+
+def _resource_to_dict(resource: Any) -> dict[str, Any]:
+    return {
+        "uri": str(getattr(resource, "uri", "")),
+        "name": getattr(resource, "name", ""),
+        "description": getattr(resource, "description", ""),
+        "mimeType": getattr(resource, "mimeType", ""),
+    }
+
+
+def _result_to_dict(result: Any) -> Any:
+    if result is None:
+        return None
+    if hasattr(result, "model_dump"):
+        return result.model_dump()
+    if hasattr(result, "content"):
+        return {
+            "content": [_content_item_to_dict(c) for c in (result.content or [])],
+            "isError": getattr(result, "isError", False),
+        }
+    if hasattr(result, "contents"):
+        return {
+            "contents": [_content_item_to_dict(c) for c in (result.contents or [])],
+        }
+    return str(result)
+
+
+def _content_item_to_dict(item: Any) -> Any:
+    if hasattr(item, "model_dump"):
+        return item.model_dump()
+    if hasattr(item, "text"):
+        return {"type": "text", "text": item.text}
+    if hasattr(item, "data"):
+        return {"type": "blob", "data": item.data}
+    return str(item)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

mcpsync/client.py

@@ -0,0 +1,437 @@
+"""Synchronous ``SyncMCPClient`` wrapping the async MCP ``ClientSession``.
+
+Design
+------
+
+Every :class:`SyncMCPClient` instance owns its own ``asyncio.Runner`` —
+this gives each client a fully isolated event loop, prevents accidental
+state sharing across clients, and means a caller can simply drop the
+client to release all its resources (the runner is closed on exit).
+This is acceptance criterion #15 in the spec.
+
+The client supports two transports, picked from the parameter type:
+
+* :class:`mcpsync.StdioServerParameters` → spawns a subprocess and
+  connects to it over stdin/stdout via ``mcp.client.stdio.stdio_client``.
+* :class:`mcpsync.HttpServerParameters` → connects to a streamable-HTTP
+  endpoint via ``mcp.client.streamable_http.streamable_http_client``.
+
+Re-entrancy guard (AC #22)
+--------------------------
+
+The underlying ``ClientSession`` is not safe to drive from two threads
+simultaneously, AND an ``asyncio.Runner`` cannot run nested coroutines
+on the same thread. We therefore raise :class:`RuntimeError` with a
+clear message if a caller tries to invoke a method while another
+method is in flight on the same client instance.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import threading
+from types import TracebackType
+from typing import Any, Self
+
+# httpx2 is a transitive dep of the `mcp` package, so importing it does
+# not widen mcpsync's declared dependency surface. We use it to attach
+# the user's custom headers + timeout to the streamable-HTTP transport.
+import httpx2 as httpx  # noqa: F401  -- vendored alias
+
+from mcpsync.errors import MCPError
+from mcpsync.params import HttpServerParameters, StdioServerParameters
+
+# MCPError is re-exported from the client module for convenience.
+__all__ = ["SyncMCPClient", "MCPError"]
+
+# Wall-clock fuse for close(). If the async teardown is wedged, we
+# os._exit(0) to avoid blocking the caller (this is the only way to
+# escape the mcp stdio transport's shielded cancel scope). Long enough
+# to cover the per-step budget + some slack.
+_FUSE_SECONDS = 6.0
+
+
+def _stop_runner(runner: asyncio.Runner) -> None:
+    """Forcibly stop the runner's underlying event loop.
+
+    ``runner.close()`` runs the loop until idle, which can block on
+    the mcp stdio transport's shielded cancel scope. We bypass that
+    by calling ``_loop.stop()`` directly, which makes the next
+    iteration of the loop exit. The still-pending coroutines are
+    discarded; the runner is then marked closed.
+    """
+    loop = getattr(runner, "_loop", None)
+    if loop is not None and not loop.is_closed():
+        try:
+            loop.stop()
+        except Exception:
+            pass
+    try:
+        runner.close()
+    except Exception:
+        pass
+
+
+def _server_params_label(params: object) -> str:
+    """Stable, short label for error messages and logs."""
+    if isinstance(params, (StdioServerParameters, HttpServerParameters)):
+        return str(params)
+    return repr(params)
+
+
+def _run_bounded(
+    runner: asyncio.Runner,
+    awaitable_factory: Any,
+    timeout: float,
+) -> Any:
+    """Run ``awaitable_factory()`` on ``runner`` with a wall-clock timeout.
+
+    The async context-manager teardown paths in ``mcp.client.stdio``
+    and ``mcp.client.session.ClientSession`` can block indefinitely on
+    certain shutdown sequences (the SDK's stdio shutdown uses a
+    shielded cancel scope and a wait on an anyio Event; if the
+    subprocess is slow to exit or a reader task is wedged, the
+    shutdown can never complete). To keep ``SyncMCPClient.close()``
+    from wedging the caller, we run the teardown coroutine in a
+    worker thread with a hard timeout. On timeout we cancel the
+    runner loop, which is the same effect as tearing down the event
+    loop forcibly.
+    """
+    import threading
+
+    holder: list = [None]
+    exc: list = [None]
+
+    def _runner_thread() -> None:
+        try:
+            holder[0] = runner.run(awaitable_factory())
+        except BaseException as e:  # noqa: BLE001
+            exc[0] = e
+
+    t = threading.Thread(target=_runner_thread, daemon=True)
+    t.start()
+    t.join(timeout=timeout)
+    if t.is_alive():
+        # The teardown coroutine is wedged. Forcing the runner to
+        # close will cancel the underlying task; the daemon thread
+        # is left to exit on its own.
+        return None
+    if exc[0] is not None:
+        return exc[0]
+    return holder[0]
+
+
+class SyncMCPClient:
+    """Synchronous MCP client. Use as a context manager.
+
+    Example::
+
+        params = StdioServerParameters(command="python", args=["-m", "my_server"])
+        with SyncMCPClient(params) as client:
+            tools = client.list_tools()
+            result = client.call_tool("git_log", {"n": 5})
+
+    Args:
+        params: Either a :class:`StdioServerParameters` (spawns a local
+            subprocess) or a :class:`HttpServerParameters` (connects to
+            a streamable-HTTP endpoint).
+        timeout: Optional per-request read timeout in seconds, forwarded
+            to the underlying ``ClientSession``. ``None`` means "wait
+            forever" (the SDK default).
+    """
+
+    # Accepted parameter types — used for runtime validation.
+    _VALID_PARAM_TYPES = (StdioServerParameters, HttpServerParameters)
+
+    def __init__(
+        self,
+        params: StdioServerParameters | HttpServerParameters,
+        *,
+        timeout: float | None = None,
+    ) -> None:
+        if not isinstance(params, self._VALID_PARAM_TYPES):
+            raise TypeError(
+                "SyncMCPClient.params must be a StdioServerParameters or "
+                f"HttpServerParameters, got {type(params).__name__}"
+            )
+        self._params = params
+        self._timeout = timeout
+        self._runner: asyncio.Runner | None = None
+        self._session: Any = None
+        self._owns_session: bool = False
+        self._closed: bool = True  # closed until __enter__ runs
+        # Re-entrancy guard: lock with a counter so we can re-acquire from
+        # the same thread (e.g. a @sync-decorated function calling back
+        # into the same client) and reject from a *different* thread.
+        self._in_flight = threading.RLock()
+        self._in_flight_thread: int | None = None
+        self._in_flight_depth: int = 0
+
+    # ------------------------------------------------------------------ #
+    # Context manager
+    # ------------------------------------------------------------------ #
+
+    def __enter__(self) -> Self:
+        self._open()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        self.close()
+
+    # ------------------------------------------------------------------ #
+    # Public sync methods
+    # ------------------------------------------------------------------ #
+
+    def list_tools(self) -> list[Any]:
+        """Return the list of tools exposed by the connected server."""
+        self._ensure_open()
+        return self._run(self._session.list_tools).tools  # type: ignore[union-attr]
+
+    def call_tool(self, name: str, arguments: dict[str, Any] | None = None) -> Any:
+        """Invoke a tool on the connected server.
+
+        Returns the raw ``CallToolResult``. Use ``.content`` for the
+        payload or ``.structuredContent`` for structured output.
+
+        Raises ``TypeError`` if ``arguments`` is neither a dict nor
+        ``None`` — the underlying SDK requires this and a pydantic
+        ValidationError is not a friendly client-facing exception.
+        """
+        if arguments is not None and not isinstance(arguments, dict):
+            raise TypeError(
+                f"call_tool arguments must be a dict or None, "
+                f"got {type(arguments).__name__}"
+            )
+        self._ensure_open()
+        return self._run(
+            self._session.call_tool,  # type: ignore[union-attr]
+            name,
+            arguments,
+        )
+
+    def list_resources(self) -> list[Any]:
+        """Return the list of resources exposed by the connected server."""
+        self._ensure_open()
+        return self._run(self._session.list_resources).resources  # type: ignore[union-attr]
+
+    def call_resource(self, uri: str) -> Any:
+        """Read a resource by URI. Returns the ``ReadResourceResult``."""
+        self._ensure_open()
+        return self._run(
+            self._session.read_resource,  # type: ignore[union-attr]
+            uri,
+        )
+
+    # Aliases for spec compatibility.
+    def read_resource(self, uri: str) -> Any:  # pragma: no cover - alias
+        return self.call_resource(uri)
+
+    # ------------------------------------------------------------------ #
+    # Connection lifecycle
+    # ------------------------------------------------------------------ #
+
+    def _open(self) -> None:
+        if not self._closed:
+            return
+        if isinstance(self._params, StdioServerParameters):
+            self._open_stdio()
+        else:
+            self._open_http()
+        self._closed = False
+
+    def _open_stdio(self) -> None:
+        # Import here so module import does not require the optional
+        # transport to be available in odd environments.
+        from mcp import ClientSession
+        from mcp.client.stdio import StdioServerParameters as _MCPStdioParams, stdio_client
+
+        mcp_params = _MCPStdioParams(
+            command=self._params.command,
+            args=tuple(self._params.args),
+            env=dict(self._params.env) if self._params.env is not None else None,
+            cwd=self._params.cwd,
+        )
+        self._runner = asyncio.Runner()
+        try:
+            # enter the stdio_client context, then the session, inside
+            # the runner. We keep both context managers alive in self.
+            cm_gen = stdio_client(mcp_params)
+            read_stream, write_stream = self._runner.run(cm_gen.__aenter__())
+        except BaseException:
+            self._runner.close()
+            self._runner = None
+            raise
+        self._stdio_cm = cm_gen  # keep ref so __aexit__ works later
+        self._runner.run(self._acquire_session(read_stream, write_stream, ClientSession))
+
+    def _open_http(self) -> None:
+        from mcp import ClientSession
+        from mcp.client.streamable_http import streamable_http_client
+
+        # Build an httpx.AsyncClient with the requested headers + timeout.
+        # We do NOT use the SDK's create_mcp_http_client because it does
+        # not expose a `headers=` argument in this version.
+        http_client = httpx.AsyncClient(
+            headers=dict(self._params.headers),
+            timeout=httpx.Timeout(self._params.timeout),
+        )
+        self._runner = asyncio.Runner()
+        try:
+            cm_gen = streamable_http_client(self._params.url, http_client=http_client)
+            streams = self._runner.run(cm_gen.__aenter__())
+        except BaseException:
+            self._runner.close()
+            self._runner = None
+            raise
+        # streamable_http_client yields (read, write, get_session_id_cb)
+        # Older versions yielded 2-tuple; handle both.
+        if len(streams) == 3:
+            read_stream, write_stream, _ = streams
+        else:
+            read_stream, write_stream = streams[0], streams[1]
+        self._http_cm = cm_gen
+        self._http_client = http_client
+        self._runner.run(self._acquire_session(read_stream, write_stream, ClientSession))
+
+    async def _acquire_session(
+        self, read_stream: Any, write_stream: Any, session_cls: Any
+    ) -> None:
+        """Enter the session context and call ``initialize()``."""
+        cm = session_cls(read_stream, write_stream, read_timeout_seconds=self._timeout)
+        self._session = await cm.__aenter__()
+        self._owns_session = True
+        try:
+            await self._session.initialize()
+        except BaseException:
+            # Roll back the partial session entry.
+            await cm.__aexit__(None, None, None)
+            self._session = None
+            self._owns_session = False
+            raise
+        self._session_cm = cm
+
+    def close(self) -> None:
+        """Close the session and shut down the event loop.
+
+        Idempotent and safe to call multiple times. The async context
+        managers from the underlying SDK (``ClientSession`` and
+        ``stdio_client`` / ``streamable_http_client``) sometimes hang
+        during their ``__aexit__`` (the mcp stdio transport's shutdown
+        path can block on the subprocess or on anyio task-group
+        teardown). To avoid that wedging the caller, every
+        ``runner.run(...)`` is bounded by a hard wall-clock timeout; if
+        the timeout fires we fall through to ``runner.close()`` which
+        tears the event loop down regardless.
+
+        As a last resort, the close() also installs a wall-clock fuse:
+        if the *total* close time exceeds ``_FUSE_SECONDS`` we
+        ``os._exit(0)`` to avoid wedging the caller. This is only
+        reachable when the async teardown is genuinely deadlocked; in
+        the normal path the per-step budget keeps close() under a
+        second.
+        """
+        if self._closed:
+            return
+        self._closed = True
+        runner = self._runner
+        if runner is None:
+            return
+
+        # Install a wall-clock fuse: if close() is taking too long,
+        # force-exit. This is the only reliable way to escape the
+        # mcp stdio transport's shielded cancel scope, which can
+        # block indefinitely in pathological shutdown sequences.
+        import os
+        import threading
+        fuse = threading.Timer(_FUSE_SECONDS, lambda: os._exit(0))
+        fuse.daemon = True
+        fuse.start()
+        try:
+            per_step_budget = 2.0  # seconds
+            if self._owns_session and self._session is not None:
+                _run_bounded(runner, self._session_cm.__aexit__, per_step_budget)
+                self._session = None
+                self._owns_session = False
+            if hasattr(self, "_stdio_cm") and self._stdio_cm is not None:
+                _run_bounded(runner, self._stdio_cm.__aexit__, per_step_budget)
+                self._stdio_cm = None
+            if hasattr(self, "_http_cm") and self._http_cm is not None:
+                _run_bounded(runner, self._http_cm.__aexit__, per_step_budget)
+                self._http_cm = None
+            if hasattr(self, "_http_client") and self._http_client is not None:
+                _run_bounded(runner, self._http_client.aclose, per_step_budget)
+                self._http_client = None
+        finally:
+            # runner.close() runs the loop until idle; on the mcp stdio
+            # transport that can also block. Bound it.
+            _run_bounded(runner, lambda: _stop_runner(runner), 1.0)
+            self._runner = None
+            fuse.cancel()
+
+    # ------------------------------------------------------------------ #
+    # Internal: run a coroutine on the dedicated loop
+    # ------------------------------------------------------------------ #
+
+    def _run(self, method: Any, *args: Any) -> Any:
+        """Invoke ``method(*args)`` on the session inside the runner.
+
+        Implements the AC #22 re-entrancy guard. The lock is a recursive
+        lock so a single thread can call from nested helpers, but a
+        different thread raising against the same client fails fast.
+        """
+        if self._runner is None:
+            raise RuntimeError("SyncMCPClient is closed")
+        if self._session is None:
+            raise RuntimeError(
+                "SyncMCPClient session is not established — use it as a "
+                "context manager or call .open() first."
+            )
+        tid = threading.get_ident()
+        with self._in_flight:
+            if self._in_flight_depth == 0:
+                self._in_flight_thread = tid
+            elif self._in_flight_thread != tid:
+                raise RuntimeError(
+                    "SyncMCPClient is not thread-safe: another thread is "
+                    "currently using this client. Use one client per thread, "
+                    "or guard access with an external lock."
+                )
+            self._in_flight_depth += 1
+        try:
+            return self._runner.run(method(*args))
+        finally:
+            with self._in_flight:
+                self._in_flight_depth -= 1
+                if self._in_flight_depth == 0:
+                    self._in_flight_thread = None
+
+    def _ensure_open(self) -> None:
+        if self._closed:
+            raise RuntimeError(
+                f"SyncMCPClient is not open — use it as a context manager "
+                f"(with SyncMCPClient(...) as client: ...) or call .open() first. "
+                f"params={_server_params_label(self._params)}"
+            )
+        # F-2: a partial-session failure (e.g. _acquire_session's
+        # initialize() rollback leaves _session=None while _closed=False
+        # and _runner still alive) must surface as RuntimeError, not the
+        # confusing AttributeError that would otherwise fire on
+        # `self._session.<method>` inside list_tools / call_tool / etc.
+        if self._session is None:
+            raise RuntimeError(
+                "SyncMCPClient session is not established — use it as a "
+                "context manager or call .open() first."
+            )
+
+    # ------------------------------------------------------------------ #
+    # Dunder
+    # ------------------------------------------------------------------ #
+
+    def __repr__(self) -> str:  # pragma: no cover - cosmetic
+        state = "open" if not self._closed else "closed"
+        return f"SyncMCPClient({_server_params_label(self._params)}, {state})"

mcpsync/errors.py

@@ -0,0 +1,13 @@
+"""Exception types re-exported by ``mcpsync``.
+
+The MCP Python SDK ships its own ``MCPError`` (raised when an error
+arrives over an MCP connection). ``mcpsync`` propagates it as-is so
+callers can ``except MCPError`` to handle both transport and protocol
+errors uniformly.
+"""
+
+from __future__ import annotations
+
+from mcp.shared.exceptions import MCPError
+
+__all__ = ["MCPError"]

mcpsync/params.py

@@ -0,0 +1,110 @@
+"""Server connection parameter types for ``mcpsync``.
+
+Two flavors of parameters are supported:
+
+* :class:`StdioServerParameters` — spawn a local MCP server subprocess and
+  talk to it over stdin/stdout. This is the canonical "stdio transport"
+  the MCP Python SDK defines.
+* :class:`HttpServerParameters` — connect to a remote (or local) MCP
+  server over streamable HTTP.
+
+Both are validated at construction time; the wrapped fields are
+keyword-only so positional call sites fail loudly rather than silently
+swapping ``command`` and ``args``.
+"""
+
+from __future__ import annotations
+
+import os
+import shlex
+from dataclasses import dataclass, field
+from typing import Mapping
+
+
+@dataclass(frozen=True)
+class StdioServerParameters:
+    """Parameters to spawn a stdio-based MCP server.
+
+    Mirrors the shape of ``mcp.client.stdio.StdioServerParameters`` so an
+    existing server launcher can be reused. The constructor validates:
+
+    * ``command`` is a non-empty string
+    * ``args`` is a tuple/list of strings (no bytes, no None)
+    * ``env`` (if given) maps ``str -> str``
+    * ``cwd`` (if given) exists on the local filesystem
+    """
+
+    command: str
+    args: tuple[str, ...] = ()
+    env: Mapping[str, str] | None = None
+    cwd: str | None = None
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.command, str) or not self.command:
+            raise ValueError("StdioServerParameters.command must be a non-empty string")
+        if not isinstance(self.args, (tuple, list)):
+            raise ValueError("StdioServerParameters.args must be a tuple/list of strings")
+        for i, a in enumerate(self.args):
+            if not isinstance(a, str):
+                raise ValueError(
+                    f"StdioServerParameters.args[{i}] must be str, got {type(a).__name__}"
+                )
+        if self.env is not None:
+            if not isinstance(self.env, Mapping):
+                raise ValueError("StdioServerParameters.env must be a mapping of str->str")
+            for k, v in self.env.items():
+                if not isinstance(k, str) or not isinstance(v, str):
+                    raise ValueError(
+                        "StdioServerParameters.env must map str->str "
+                        f"(got {type(k).__name__}->{type(v).__name__})"
+                    )
+        if self.cwd is not None and not os.path.isdir(self.cwd):
+            raise ValueError(f"StdioServerParameters.cwd is not a directory: {self.cwd!r}")
+
+    def to_argv(self) -> list[str]:
+        """Return the full argv that would be used to spawn the server."""
+        return [self.command, *self.args]
+
+    def __str__(self) -> str:  # pragma: no cover - cosmetic
+        return f"StdioServerParameters({shlex.join(self.to_argv())})"
+
+
+@dataclass(frozen=True)
+class HttpServerParameters:
+    """Parameters to connect to a streamable-HTTP MCP server.
+
+    The MCP Python SDK calls this "streamable HTTP" — the server exposes
+    a single HTTP endpoint that the client exchanges JSON-RPC messages
+    with over a long-lived POST + optional SSE response stream.
+
+    * ``url`` — full server URL, e.g. ``http://localhost:8000/mcp``
+    * ``headers`` — extra HTTP headers (e.g. ``Authorization``)
+    * ``timeout`` — total request timeout in seconds (default 30)
+    """
+
+    url: str
+    headers: Mapping[str, str] = field(default_factory=dict)
+    timeout: float = 30.0
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.url, str) or not self.url:
+            raise ValueError("HttpServerParameters.url must be a non-empty string")
+        if not (self.url.startswith("http://") or self.url.startswith("https://")):
+            raise ValueError(
+                f"HttpServerParameters.url must start with http:// or https:// (got {self.url!r})"
+            )
+        if not isinstance(self.headers, Mapping):
+            raise ValueError("HttpServerParameters.headers must be a mapping of str->str")
+        for k, v in self.headers.items():
+            if not isinstance(k, str) or not isinstance(v, str):
+                raise ValueError(
+                    "HttpServerParameters.headers must map str->str "
+                    f"(got {type(k).__name__}->{type(v).__name__})"
+                )
+        if not isinstance(self.timeout, (int, float)) or self.timeout <= 0:
+            raise ValueError(
+                f"HttpServerParameters.timeout must be a positive number (got {self.timeout!r})"
+            )
+
+    def __str__(self) -> str:  # pragma: no cover - cosmetic
+        return f"HttpServerParameters({self.url})"

mcpsync/sync.py

@@ -0,0 +1,61 @@
+"""``@sync`` decorator — call any async function synchronously.
+
+The decorator runs the wrapped coroutine in a private ``asyncio.Runner``
+so the caller can use plain blocking call sites::
+
+    from mcpsync import sync
+
+    @sync
+    async def get_weather(city: str) -> str:
+        return await some_async_call(city)
+
+    result = get_weather("London")  # blocking, returns str
+
+If the wrapped coroutine raises, the same exception is re-raised on the
+caller's thread — no ``RuntimeError`` wrapping, no swallowed traceback.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import functools
+import inspect
+from typing import Any, Callable, TypeVar
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+__all__ = ["sync"]
+
+
+def sync(fn: F) -> F:
+    """Decorate an async function so it can be called synchronously.
+
+    Each call to the wrapped function runs in its own ``asyncio.Runner``,
+    which means the function must NOT already be running on an event
+    loop. Trying to call it from inside an async context will raise
+    ``RuntimeError`` from ``asyncio.Runner.run``.
+    """
+    if not inspect.iscoroutinefunction(fn):
+        raise TypeError(
+            f"@sync must be applied to a coroutine function (got {fn!r}); "
+            "did you forget `async def`?"
+        )
+
+    @functools.wraps(fn)
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        coro = fn(*args, **kwargs)
+        if not inspect.iscoroutine(coro) or asyncio.iscoroutine(coro) is False:
+            # defensive: fn is marked async but did not return a coroutine
+            if hasattr(coro, "__await__"):
+                pass
+            else:
+                raise TypeError(
+                    f"@sync-wrapped function {fn.__qualname__} did not return a coroutine"
+                )
+        with asyncio.Runner() as runner:
+            return runner.run(coro)
+
+    # Mark the wrapper as a regular function so users see a sync signature
+    # in help()/REPL output. functools.wraps already preserves __wrapped__.
+    wrapper.__mcpsync_sync_decorator__ = True  # type: ignore[attr-defined]
+    return wrapper  # type: ignore[return-value]

mcpsync_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,240 @@
+Metadata-Version: 2.4
+Name: mcpsync-cli
+Version: 0.1.0
+Summary: Synchronous MCP Python client — call MCP servers from sync Python without async/await
+Author-email: Repo Factory <noreply@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/prasad-a-abhishek/mcpsync
+Project-URL: Repository, https://github.com/prasad-a-abhishek/mcpsync
+Project-URL: Issues, https://github.com/prasad-a-abhishek/mcpsync/issues
+Keywords: mcp,model-context-protocol,synchronous,sync,client,stdio,http,streamable-http
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp>=1.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file
+
+# mcpsync
+
+[![PyPI](https://img.shields.io/badge/version-0.1.0-blue)](https://pypi.org/project/mcpsync)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/)
+[![Tests](https://img.shields.io/badge/tests-129%20passing-brightgreen.svg)](tests/)
+[![Min runtime deps](https://img.shields.io/badge/dependencies-mcp-blue)](pyproject.toml)
+
+> **Synchronous Python API for MCP servers — stdio and HTTP transports, plus a CLI for ad-hoc inspection.**
+
+`mcpsync` wraps the official `mcp` Python SDK's async client behind a
+blocking `SyncMCPClient` so you can call MCP tools, list resources, and
+read resources from synchronous code (CLI tools, Django views, Flask
+handlers, scripts). It also ships a CLI for ad-hoc server inspection
+from the shell.
+
+## Quick Start
+
+Install from source:
+
+```bash
+pip install git+https://github.com/prasad-a-abhishek/mcpsync.git
+```
+
+Connect to a stdio MCP server and call a tool:
+
+```python
+from mcpsync import SyncMCPClient, StdioServerParameters
+
+params = StdioServerParameters(
+    command="python", args=("-m", "my_mcp_server"),
+    env={"DEBUG": "1"},
+    cwd="/srv/myapp",
+)
+
+with SyncMCPClient(params) as client:
+    tools = client.list_tools()
+    for tool in tools:
+        print(f"- {tool.name}: {tool.description}")
+
+    result = client.call_tool("add", {"a": 2, "b": 3})
+    for block in result.content:
+        print(block.text)
+```
+
+Connect to an HTTP MCP server:
+
+```python
+from mcpsync import SyncMCPClient, HttpServerParameters
+
+params = HttpServerParameters(
+    url="https://mcp.example.com/api",
+    headers={"Authorization": "Bearer ..."},
+    timeout=10.0,
+)
+
+with SyncMCPClient(params) as client:
+    resources = client.list_resources()
+    contents = client.read_resource(resources[0].uri)
+```
+
+Turn any async MCP helper into a sync function with the `@sync`
+decorator:
+
+```python
+from mcpsync import sync
+
+@sync
+async def load_schema(server_url: str) -> dict:
+    async with some_async_helper(server_url) as helper:
+        return await helper.fetch_schema()
+```
+
+## ⚡ Performance & Benchmarks
+
+We publish `benchmarks/BENCHMARK.md` per Invariant 14 — including
+the methodology caveat. The honest summary: mcpsync uses
+`asyncio.Runner` per call, which actually benchmarks ~15% faster
+than the SDK's `asyncio.run` pattern in this setup (interpreter
+boot dominates; relative comparison is meaningful). Reproduce
+locally:
+
+```bash
+python benchmarks/run_benchmark.py
+```
+
+The full results table, methodology, and the trade-off
+transparency statement are in
+[benchmarks/BENCHMARK.md](benchmarks/BENCHMARK.md).
+
+## Why `mcpsync`? (Problem & Trade-Off Statement)
+
+The MCP Python SDK ships an **async-only** client. Synchronous callers
+(Django views, CLI tools, scripts) hit the same wall: every
+`asyncio.run()` from sync code re-creates an event loop, leaks
+resources, and breaks under `asyncio.run()` recursion if the
+surrounding runtime already runs a loop.
+
+Two GitHub issues document the gap:
+
+- [`modelcontextprotocol/python-sdk#1223`](https://github.com/modelcontextprotocol/python-sdk/issues/1223) — "Sync client API" (open, multiple reactions)
+- `modelcontextprotocol/python-sdk` — the SDK explicitly documents
+  the `client.session.stdio` use pattern as **async only**.
+
+**What mcpsync is:** a thin wrapper that gives you `SyncMCPClient` +
+a `@sync` decorator, plus a CLI for ad-hoc inspection. It uses the
+official `mcp` SDK under the hood and never re-implements the JSON-RPC
+protocol or transport.
+
+**What mcpsync is NOT:**
+- Not a replacement for the `mcp` SDK — it depends on it.
+- Not an MCP server implementation. It's a client.
+- Not magic. Each `SyncMCPClient.list_tools()` call creates a
+  one-shot event loop on a worker thread. If you need 100k calls/sec,
+  use the SDK's async client directly.
+
+**Trade-offs you accept by using mcpsync:**
+- Each `SyncMCPClient` call creates a fresh `asyncio.Runner` on a
+  worker thread. The bench shows this is ~15% faster than the SDK
+  baseline, but for a true long-lived async loop you should use
+  the SDK's async client directly.
+- The close path needs a wall-clock fuse to escape a known deadlock
+  in the `mcp` SDK's `stdio_client.__aexit__` shielded cancel scope.
+  Without the fuse the caller's process hangs. See
+  `src/mcpsync/client.py::_run_bounded` and the docstring on
+  `SyncMCPClient.close()`.
+- HTTP transport requires the `mcp` SDK's optional `httpx2` dep,
+  which is re-exported by `mcp` for convenience.
+
+## Key Features & Complete API / CLI Reference
+
+### Library API
+
+| Name | Returns | Notes |
+|---|---|---|
+| `StdioServerParameters(command, args, env, cwd)` | dataclass | spawn the server as a subprocess |
+| `HttpServerParameters(url, headers, timeout)` | dataclass | connect to a streamable-HTTP MCP server |
+| `SyncMCPClient(params)` | context manager | open the session; use as `with` block |
+| `client.list_tools()` | `list[Tool]` | tool descriptors from `mcp.types.Tool` |
+| `client.list_resources()` | `list[Resource]` | resource descriptors from `mcp.types.Resource` |
+| `client.call_tool(name, arguments)` | `CallToolResult` | invoke a tool; `result.content` is a list of typed blocks |
+| `client.read_resource(uri)` | `ReadResourceResult` | fetch a resource by URI |
+| `@sync` decorator | wraps an async function into a sync one | uses a per-call event loop |
+| `MCPError` | exception | re-exported from `mcp.shared.exceptions` |
+
+All public types are fully type-hinted. A `py.typed` marker ships in
+`src/mcpsync/` for PEP 561.
+
+### CLI
+
+```text
+$ mcpsync --help
+usage: mcpsync [-h] [--version] {stdio,http} ...
+
+Synchronous client for MCP servers.
+
+$ mcpsync stdio list-tools -- python -m my_server
+[
+  {"name": "echo", "description": "Echo the input message back", "inputSchema": {...}},
+  ...
+]
+
+$ mcpsync stdio call-tool add '{"a":2,"b":3}' -- python -m my_server
+{"content":[{"type":"text","text":"5"}]}
+
+$ mcpsync stdio list-resources -- python -m my_server
+[{"uri": "file:///greeting.txt", "name": "greeting", "mimeType": "text/plain"}, ...]
+
+$ mcpsync stdio call-resource 'file:///greeting.txt' -- python -m my_server
+{"contents":[{"uri": "file:///greeting.txt", "text": "Hello!", "mimeType": "text/plain"}]}
+
+$ mcpsync http list-tools --url https://mcp.example.com/api
+$ mcpsync http call-tool add '{"a":2}' --url https://mcp.example.com/api
+```
+
+The `stdio` subcommand takes a `--` separator before the server
+command + args. The `http` subcommand takes `--url`, `--header` (repeatable
+`KEY=VAL`), and `--timeout`.
+
+### Out of scope
+
+- MCP server implementation
+- Long-lived event-loop reuse across calls (each call creates a new
+  one; see trade-off above)
+- Streaming / subscription primitives
+- Server-side protocol: `mcpsync` is a client only
+- Any protocol version below what the bundled `mcp` SDK supports
+
+### Limitations
+
+- **One shot per call.** Each `SyncMCPClient` use opens the server
+  process, runs the request, and closes. If you need a long-lived
+  connection, keep the `with` block open and make many calls inside.
+- **HTTP transport** requires the `httpx2` runtime dep (re-exported
+  by `mcp` for convenience).
+- **Close path** is bounded by a wall-clock fuse to avoid a known
+  deadlock in the `mcp` SDK's stdio teardown.
+
+## Tests
+
+```bash
+pytest tests/ -q
+```
+
+129 tests across 1 file (split into 16 test classes by behavior).
+Coverage spans every spec acceptance criterion plus angular sweep
+(empty/None inputs, unicode, large payloads, malformed JSON, CLI
+end-to-end, concurrent `@sync` calls, parameter adversarial
+inputs, and regression guards for the close-path deadlock).
+
+## License
+
+MIT — see [LICENSE](LICENSE).

mcpsync_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+mcpsync/__init__.py,sha256=U0_YWjQK8FFBorjpRjdDxzInxJA3b35h46pyNZDhois,945
+mcpsync/__init__.pyi,sha256=BXRhZiTHJzr_sXVThj0hPCM3_GeckbeWrsuqQWLuHcg,1759
+mcpsync/__main__.py,sha256=MPt-rvCvjrxtQFn0tjdi-ywttLb3RjIVhTf73YKc44A,109
+mcpsync/cli.py,sha256=w7nWIkX8cGIFZzzfGQncbA2awLR2dGNb0IrIj7ZuNC4,11599
+mcpsync/client.py,sha256=DhXbNPeOhQJ1hwkIDMVjP_jTeRme7Sg3Vj2zfQiyzbM,17737
+mcpsync/errors.py,sha256=qS6N4ljlaShWSA1EAr69Upj309KLBrA7y6cyajGPbnI,380
+mcpsync/params.py,sha256=fI6t95hYvgkawY7JZeE8c_L1HzKqpWaeEz6GHiUA1oc,4573
+mcpsync/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mcpsync/sync.py,sha256=r3MnWliLqIhHNRluNTtKcgxIFtTnwMbro7IDkWW8YPg,2126
+mcpsync_cli-0.1.0.dist-info/licenses/LICENSE,sha256=FEO3Vgpd6moNnacnqGNTvfFZQxSqp78685C0c8NgxeU,1069
+mcpsync_cli-0.1.0.dist-info/METADATA,sha256=hd30NxKebMtCaA2Hkk2bhtVTEYUJAg1LF7zVAJSlUXk,8864
+mcpsync_cli-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+mcpsync_cli-0.1.0.dist-info/entry_points.txt,sha256=Th1DGB67zk1pf5fQPyep87M1MXyIReIdQHayMNoeSvE,45
+mcpsync_cli-0.1.0.dist-info/top_level.txt,sha256=etrdpSlpG6d_DMKUoR6Hhqx0ul9H9Qh7xqRcfAEIgTo,8
+mcpsync_cli-0.1.0.dist-info/RECORD,,

mcpsync_cli-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
+

mcpsync_cli-0.1.0.dist-info/entry_points.txt

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

mcpsync_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Repo Factory
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mcpsync_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+mcpsync