mcp-curl 0.2.1__py3-none-any.whl

mcp_curl-0.2.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mike D
+
+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.

mcp_curl-0.2.1.dist-info/METADATA

@@ -0,0 +1,383 @@
+Metadata-Version: 2.2
+Name: mcp-curl
+Version: 0.2.1
+Summary: A curl-like CLI tool for interacting with Model Context Protocol (MCP) servers
+Author: turlockmike
+License: MIT
+Project-URL: Homepage, https://github.com/turlockmike/murl
+Project-URL: Repository, https://github.com/turlockmike/murl
+Project-URL: Issues, https://github.com/turlockmike/murl/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.0.0
+Requires-Dist: mcp>=1.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: requests>=2.31.0; extra == "dev"
+
+# murl - MCP Curl
+
+[![Tests](https://github.com/turlockmike/murl/actions/workflows/test.yml/badge.svg)](https://github.com/turlockmike/murl/actions/workflows/test.yml)
+
+A curl-like CLI tool for interacting with Model Context Protocol (MCP) servers.
+
+## What is MCP?
+
+MCP (Model Context Protocol) is an open standard developed by Anthropic for AI models to access external data sources, tools, and services. It provides a universal way for large language models (LLMs) to interact with various resources securely and efficiently.
+
+## Quick Start
+
+### Option 1: Try with Public MCP Servers (No Setup Required)
+
+Test murl immediately with public MCP servers:
+
+```bash
+# Install murl
+curl -sSL https://raw.githubusercontent.com/turlockmike/murl/master/install.sh | bash
+# Or using pip: pip install mcp-curl
+
+# List available tools on the echo server
+murl https://echo.mcp.inevitable.fyi/mcp/tools
+
+# Call the echo tool with a message
+murl https://echo.mcp.inevitable.fyi/mcp/tools/echo -d message="Hello from murl!"
+
+# Try the everything server with multiple tools
+murl https://everything.mcp.inevitable.fyi/mcp/tools
+
+# Get current time from the time server
+murl https://time.mcp.inevitable.fyi/mcp/tools/get_current_time
+```
+
+**Available public test servers:**
+- Echo Server: `https://echo.mcp.inevitable.fyi/mcp` - Simple echo tool for testing
+- Everything Server: `https://everything.mcp.inevitable.fyi/mcp` - Multipurpose server with various capabilities
+- Time Server: `https://time.mcp.inevitable.fyi/mcp` - Time-related tools
+
+### Option 2: Quick Local Setup with mcp-proxy
+
+For testing local or stdio MCP servers:
+
+```bash
+# Install murl and mcp-proxy
+curl -sSL https://raw.githubusercontent.com/turlockmike/murl/master/install.sh | bash
+pip install mcp-proxy
+# Or install murl with pip: pip install mcp-curl mcp-proxy
+
+# Start a simple time server example
+# (You'll need to have an MCP server to proxy - see the full documentation below)
+mcp-proxy --port 3000 uvx mcp-server-time
+
+# In another terminal, test with murl
+murl http://localhost:3000/tools
+murl http://localhost:3000/tools/get_current_time
+```
+
+## Installation
+
+### Quick Install (Recommended)
+
+Install murl with a single command:
+
+```bash
+curl -sSL https://raw.githubusercontent.com/turlockmike/murl/master/install.sh | bash
+```
+
+This will automatically download and install murl from source.
+
+### Using pip
+
+Install murl from PyPI:
+
+```bash
+pip install mcp-curl
+```
+
+To upgrade to the latest version:
+
+```bash
+pip install --upgrade mcp-curl
+```
+
+### Upgrade
+
+To upgrade murl to the latest version:
+
+```bash
+murl --upgrade
+```
+
+This command downloads and runs the installation script to update murl to the latest release from GitHub.
+
+### From Source
+
+```bash
+git clone https://github.com/turlockmike/murl.git
+cd murl
+pip install -e .
+```
+
+## Usage
+
+`murl` provides a curl-like interface for interacting with MCP servers over HTTP. It abstracts the JSON-RPC 2.0 protocol, making it easy to call MCP methods using intuitive REST-like paths.
+
+### Basic Syntax
+
+```bash
+murl <url> [options]
+```
+
+Where `<url>` is the MCP server endpoint with a virtual path (e.g., `http://localhost:3000/tools`).
+
+### Options
+
+- `-d, --data <key=value>` - Add data to the request. Can be used multiple times.
+- `-H, --header <key: value>` - Add custom HTTP headers (e.g., for authentication).
+- `-v, --verbose` - Enable verbose output (prints request/response details to stderr).
+- `--version` - Show detailed version information (includes Python version and installation path).
+- `--upgrade` - Upgrade murl to the latest version from GitHub releases.
+- `--help` - Show help message.
+
+### Examples
+
+#### List Available Tools
+
+```bash
+murl http://localhost:3000/tools
+```
+
+This sends a `tools/list` request to the MCP server.
+
+#### Call a Tool with Arguments
+
+```bash
+murl http://localhost:3000/tools/echo -d message=hello
+```
+
+This sends a `tools/call` request with the tool name "echo" and arguments `{"message": "hello"}`.
+
+#### Call a Tool with Multiple Arguments
+
+```bash
+murl http://localhost:3000/tools/weather -d city=Paris -d metric=true
+```
+
+Arguments are automatically type-coerced (strings, numbers, booleans).
+
+#### Call a Tool with JSON Data
+
+```bash
+murl http://localhost:3000/tools/config -d '{"settings": {"theme": "dark"}}'
+```
+
+You can pass complex JSON objects directly.
+
+#### List Available Resources
+
+```bash
+murl http://localhost:3000/resources
+```
+
+This sends a `resources/list` request.
+
+#### Read a Resource
+
+```bash
+murl http://localhost:3000/resources/path/to/file
+```
+
+This sends a `resources/read` request with the file path. The path is automatically converted to a `file://` URI.
+
+#### List Available Prompts
+
+```bash
+murl http://localhost:3000/prompts
+```
+
+This sends a `prompts/list` request.
+
+#### Get a Prompt
+
+```bash
+murl http://localhost:3000/prompts/greeting -d name=Alice
+```
+
+This sends a `prompts/get` request with the prompt name "greeting" and arguments.
+
+#### Add Authorization Headers
+
+```bash
+murl http://localhost:3000/tools -H "Authorization: Bearer token123"
+```
+
+Custom headers can be added for authentication or other purposes.
+
+#### Verbose Mode
+
+```bash
+murl http://localhost:3000/tools -v
+```
+
+Verbose mode prints the JSON-RPC request payload and HTTP headers to stderr, useful for debugging.
+
+### URL Mapping
+
+`murl` automatically maps REST-like paths to MCP JSON-RPC methods:
+
+| URL Path                  | MCP Method        | Parameters                                |
+| ------------------------- | ----------------- | ----------------------------------------- |
+| `/tools`                  | `tools/list`      | `{}`                                      |
+| `/tools/<name>`           | `tools/call`      | `{name: "<name>", arguments: {...}}`      |
+| `/resources`              | `resources/list`  | `{}`                                      |
+| `/resources/<path>`       | `resources/read`  | `{uri: "file:///<path>"}` (three slashes) |
+| `/prompts`                | `prompts/list`    | `{}`                                      |
+| `/prompts/<name>`         | `prompts/get`     | `{name: "<name>", arguments: {...}}`      |
+
+### Piping Output
+
+`murl` outputs raw JSON to stdout, making it pipe-friendly:
+
+```bash
+# Use with jq to format output
+murl http://localhost:3000/tools | jq .
+
+# Extract specific fields
+murl http://localhost:3000/tools | jq '.[0].name'
+```
+
+## Development
+
+### Setup Development Environment
+
+```bash
+# Clone the repository
+git clone https://github.com/turlockmike/murl.git
+cd murl
+
+# Install in development mode with dev dependencies
+pip install -e ".[dev]"
+```
+
+### Running Tests
+
+```bash
+pytest
+```
+
+### Running Tests with Coverage
+
+```bash
+pytest --cov=murl --cov-report=html
+```
+
+## How It Works
+
+`murl` works by:
+
+1. **Parsing the URL** to extract the base endpoint and the MCP virtual path
+2. **Mapping the virtual path** to the appropriate MCP JSON-RPC method
+3. **Parsing data flags** (`-d`) into method parameters with type coercion
+4. **Constructing a JSON-RPC 2.0 request** with the method and parameters
+5. **Sending an HTTP POST request** to the base endpoint with the JSON-RPC payload
+6. **Extracting the result** from the JSON-RPC response and printing it as JSON
+
+## Using murl with MCP Servers
+
+`murl` supports the Streamable HTTP transport protocol used by modern MCP servers. This allows murl to work with MCP servers that implement HTTP-based transport.
+
+### Streamable HTTP Support
+
+As of the latest version, murl includes comprehensive support for the MCP Streamable HTTP transport protocol:
+- Sends `Accept: application/json, text/event-stream` header
+- Handles both immediate JSON responses and Server-Sent Events (SSE) streams
+- **Supports session-based SSE** for compatibility with mcp-proxy
+- Automatically tries session-based SSE first, then falls back to regular HTTP POST
+- Compatible with MCP servers implementing the Streamable HTTP specification
+
+### Direct HTTP MCP Servers
+
+murl works best with MCP servers that expose a direct HTTP JSON-RPC endpoint. For example, if you have a server running at `http://localhost:3000` that implements MCP over HTTP:
+
+```bash
+# List available tools
+murl http://localhost:3000/tools
+
+# Call a tool with arguments
+murl http://localhost:3000/tools/my_tool -d param1=value1 -d param2=value2
+
+# List resources
+murl http://localhost:3000/resources
+
+# Get a prompt
+murl http://localhost:3000/prompts/my_prompt -d arg1=value
+```
+
+### Using murl with mcp-proxy
+
+Many MCP servers are implemented as stdio (standard input/output) programs. To use these with murl, you can expose them via HTTP using [mcp-proxy](https://github.com/sparfenyuk/mcp-proxy):
+
+```bash
+# Install mcp-proxy
+pip install mcp-proxy
+
+# Start mcp-proxy to expose a stdio MCP server on HTTP port 3000
+mcp-proxy --port 3000 python my_mcp_server.py
+
+# Or for a Node.js MCP server
+mcp-proxy --port 3000 node path/to/mcp-server.js
+```
+
+Once mcp-proxy is running, you can use murl to interact with your stdio MCP server:
+
+```bash
+# List available tools
+murl http://localhost:3000/tools
+
+# Call a tool with arguments
+murl http://localhost:3000/tools/my_tool -d param1=value1 -d param2=value2
+
+# List resources
+murl http://localhost:3000/resources
+
+# Get a prompt
+murl http://localhost:3000/prompts/my_prompt -d arg1=value
+```
+
+**How it works**: murl automatically detects mcp-proxy's session-based SSE architecture and handles it transparently:
+1. Connects to the SSE endpoint to get a session ID
+2. Posts the request to the session-specific endpoint
+3. Reads the response from the SSE stream
+4. Each murl invocation creates and closes its own ephemeral session
+
+For more information about MCP transport protocols, see the [official MCP documentation](https://modelcontextprotocol.io/specification/basic/transports).
+
+## Requirements
+
+- Python 3.10 or higher
+- `click` - For CLI argument parsing
+- `requests` - For HTTP requests
+
+## License
+
+MIT License - see LICENSE file for details
+
+## Releasing
+
+For maintainers: To create a new release, update the version in `pyproject.toml` and `murl/__init__.py`, then create and push a git tag:
+
+```bash
+git tag v0.2.1
+git push origin v0.2.1
+```
+
+This will automatically trigger a GitHub Actions workflow that builds the package and creates a GitHub release with the artifacts.

mcp_curl-0.2.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+murl/__init__.py,sha256=3Ctj8PNExLK0RkJvp_TsAXDPVyKmClhDh2mIhwL2VV4,99
+murl/cli.py,sha256=E653cZyPoa5cALlnO4Dt4Tx4ctfbYBBudiYb11iH1t8,17179
+mcp_curl-0.2.1.dist-info/LICENSE,sha256=zERRs8wBVYS6pPsaWrEnZ5_6Glito6nb4sIwBj7hIC4,1063
+mcp_curl-0.2.1.dist-info/METADATA,sha256=NT19GfJNNjVRxnJxT_DDfQ4vm7wYeq4Vx4aYxS0Lems,11329
+mcp_curl-0.2.1.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+mcp_curl-0.2.1.dist-info/entry_points.txt,sha256=8VX69QOGt5SkSca_j9vr209QE9C8uBz5-27rUNSDOU8,39
+mcp_curl-0.2.1.dist-info/top_level.txt,sha256=cmvxbiwOKJ2254P4OYZ8xkVTI7h7H1aorcFBVB4GoB0,5
+mcp_curl-0.2.1.dist-info/RECORD,,

mcp_curl-0.2.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (76.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mcp_curl-0.2.1.dist-info/entry_points.txt

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

mcp_curl-0.2.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+murl

murl/__init__.py

@@ -0,0 +1,3 @@
+"""murl - A curl-like CLI tool for Model Context Protocol (MCP) servers."""
+
+__version__ = "0.2.1"

murl/cli.py

@@ -0,0 +1,471 @@
+"""CLI entry point for murl."""
+
+import asyncio
+import json
+import os
+import re
+import subprocess
+import sys
+from typing import Dict, Any, Tuple, Optional
+
+import click
+from mcp import ClientSession
+from mcp.client.streamable_http import streamable_http_client
+from murl import __version__
+
+
+def parse_url(full_url: str) -> Tuple[str, str]:
+    """Parse the full URL into base URL and virtual path.
+    
+    Args:
+        full_url: The complete URL including the MCP path
+        
+    Returns:
+        Tuple of (base_url, virtual_path)
+        
+    Raises:
+        ValueError: If the URL doesn't contain a valid MCP path
+    """
+    # Regex to find the start of MCP segments
+    pattern = r'/(tools|resources|prompts)(\/.*)?$'
+    match = re.search(pattern, full_url)
+    
+    if not match:
+        raise ValueError(
+            "Invalid MCP URL. Must contain /tools, /resources, or /prompts"
+        )
+    
+    virtual_path = match.group(0)  # e.g., "/tools/weather"
+    base_url = full_url[:match.start()]  # e.g., "https://api.com/mcp"
+    
+    return base_url, virtual_path
+
+
+def parse_data_value(value: str) -> Any:
+    """Parse a data value and coerce types.
+    
+    Args:
+        value: The string value to parse
+        
+    Returns:
+        The parsed value (bool, int, float, or string)
+    """
+    # Try to parse as boolean
+    if value.lower() == 'true':
+        return True
+    if value.lower() == 'false':
+        return False
+    
+    # Try to parse as number
+    try:
+        # Try integer first
+        if '.' not in value:
+            return int(value)
+        # Try float
+        return float(value)
+    except ValueError:
+        pass
+    
+    # Return as string
+    return value
+
+
+def parse_data_flags(data_flags: Tuple[str, ...]) -> Dict[str, Any]:
+    """Parse -d/--data flags into a dictionary.
+    
+    Args:
+        data_flags: Tuple of data flag values
+        
+    Returns:
+        Dictionary of parsed key-value pairs
+        
+    Note:
+        JSON objects (starting with '{') are merged into the result.
+        JSON arrays (starting with '[') are not supported as they don't
+        represent key-value pairs needed for MCP arguments.
+    """
+    result = {}
+    
+    for data in data_flags:
+        # Check if it's a JSON object
+        stripped = data.strip()
+        if stripped.startswith('{'):
+            try:
+                parsed = json.loads(data)
+                if not isinstance(parsed, dict):
+                    raise ValueError(f"JSON in -d flag must be an object, not {type(parsed).__name__}")
+                result.update(parsed)
+            except json.JSONDecodeError:
+                raise ValueError(f"Invalid JSON in -d flag: {data}")
+        elif stripped.startswith('['):
+            raise ValueError(f"JSON arrays are not supported in -d flag. Use key=value or JSON objects.")
+        else:
+            # Parse key=value format
+            if '=' not in data:
+                raise ValueError(f"Invalid data format: {data}. Expected key=value or JSON")
+            
+            key, value = data.split('=', 1)
+            result[key] = parse_data_value(value)
+    
+    return result
+
+
+def map_virtual_path_to_method(virtual_path: str, data: Dict[str, Any]) -> Tuple[str, Dict[str, Any]]:
+    """Map a virtual path to an MCP JSON-RPC method and params.
+    
+    Args:
+        virtual_path: The MCP path (e.g., "/tools", "/tools/weather")
+        data: The parsed data dictionary
+        
+    Returns:
+        Tuple of (method, params)
+    """
+    # Remove leading slash and split
+    parts = virtual_path.lstrip('/').split('/')
+    
+    # Check for empty path
+    if not parts or parts == ['']:
+        raise ValueError("Invalid virtual path: empty path")
+    
+    category = parts[0]  # tools, resources, or prompts
+    
+    if category == 'tools':
+        if len(parts) == 1:
+            # /tools -> tools/list
+            return 'tools/list', {}
+        else:
+            # /tools/<name> -> tools/call
+            tool_name = parts[1]
+            return 'tools/call', {
+                'name': tool_name,
+                'arguments': data
+            }
+    
+    elif category == 'resources':
+        if len(parts) == 1:
+            # /resources -> resources/list
+            return 'resources/list', {}
+        else:
+            # /resources/<path> -> resources/read with file:// URI
+            # Join all parts after 'resources' to form the file path
+            # Prepend '/' to make it an absolute path: /resources/path/to/file -> file:///path/to/file
+            file_path = '/'.join(parts[1:])
+            # Handle empty path case (e.g., /resources/ with trailing slash)
+            if not file_path or file_path == '':
+                raise ValueError("Invalid resources path: path cannot be empty after /resources/")
+            # Ensure absolute path starts with '/'
+            if not file_path.startswith('/'):
+                file_path = '/' + file_path
+            uri = f'file://{file_path}'
+            # Merge with any additional data parameters passed via -d flags
+            return 'resources/read', {'uri': uri, **data}
+    
+    elif category == 'prompts':
+        if len(parts) == 1:
+            # /prompts -> prompts/list
+            return 'prompts/list', {}
+        else:
+            # /prompts/<name> -> prompts/get
+            prompt_name = parts[1]
+            return 'prompts/get', {
+                'name': prompt_name,
+                'arguments': data
+            }
+    
+    else:
+        raise ValueError(f"Invalid MCP category: {category}")
+
+
+def parse_headers(header_flags: Tuple[str, ...]) -> Dict[str, str]:
+    """Parse -H/--header flags into a dictionary.
+    
+    Args:
+        header_flags: Tuple of header flag values
+        
+    Returns:
+        Dictionary of headers
+    """
+    headers = {}
+    
+    for header in header_flags:
+        if ':' not in header:
+            raise ValueError(f"Invalid header format: {header}. Expected 'Key: Value'")
+        
+        key, value = header.split(':', 1)
+        headers[key.strip()] = value.strip()
+    
+    return headers
+
+
+async def make_mcp_request(
+    base_url: str,
+    method: str,
+    params: Dict[str, Any],
+    headers: Dict[str, str],
+    verbose: bool
+) -> Any:
+    """Make an MCP request using the official SDK.
+    
+    Args:
+        base_url: The base URL of the MCP server
+        method: The MCP method to call
+        params: The method parameters
+        headers: Custom HTTP headers to include in requests
+        verbose: Whether to print verbose output
+        
+    Returns:
+        The result from the MCP server (as JSON-serializable data)
+        
+    Raises:
+        Exception: If the request fails
+    """
+    # Validate required parameters before making connection
+    if method == 'tools/call':
+        if params.get('name') is None:
+            raise ValueError("Missing required 'name' parameter for tools/call method")
+    elif method == 'resources/read':
+        if params.get('uri') is None:
+            raise ValueError("Missing required 'uri' parameter for resources/read method")
+    elif method == 'prompts/get':
+        if params.get('name') is None:
+            raise ValueError("Missing required 'name' parameter for prompts/get request")
+    
+    if verbose:
+        click.echo("=== MCP Request ===", err=True)
+        click.echo(f"Method: {method}", err=True)
+        click.echo(f"Params: {json.dumps(params, indent=2)}", err=True)
+        click.echo(f"URL: {base_url}", err=True)
+        if headers:
+            click.echo(f"Headers: {json.dumps(headers, indent=2)}", err=True)
+        click.echo("", err=True)
+    
+    # Create httpx client with custom headers if provided
+    import httpx
+    http_client = None
+    if headers:
+        http_client = httpx.AsyncClient(headers=headers)
+    
+    try:
+        async with streamable_http_client(base_url, http_client=http_client) as (read, write, get_session_id):
+            async with ClientSession(read, write) as session:
+                # Initialize the session
+                init_result = await session.initialize()
+                
+                if verbose:
+                    click.echo("=== MCP Initialization ===", err=True)
+                    click.echo(f"Protocol Version: {init_result.protocolVersion}", err=True)
+                    click.echo(f"Server: {init_result.serverInfo.name} {init_result.serverInfo.version}", err=True)
+                    click.echo("", err=True)
+                
+                # Route to appropriate SDK method
+                if method == 'tools/list':
+                    result = await session.list_tools()
+                    # Convert pydantic models to dict
+                    return [tool.model_dump(mode='json', exclude_none=True) for tool in result.tools]
+                elif method == 'tools/call':
+                    tool_name = params.get('name')
+                    arguments = params.get('arguments', {})
+                    result = await session.call_tool(tool_name, arguments)
+                    # Convert content to dict
+                    return [content.model_dump(mode='json', exclude_none=True) for content in result.content]
+                elif method == 'resources/list':
+                    result = await session.list_resources()
+                    # Convert resources to dict
+                    return [resource.model_dump(mode='json', exclude_none=True) for resource in result.resources]
+                elif method == 'resources/read':
+                    uri = params.get('uri')
+                    result = await session.read_resource(uri)
+                    # Convert contents to dict
+                    return [content.model_dump(mode='json', exclude_none=True) for content in result.contents]
+                elif method == 'prompts/list':
+                    result = await session.list_prompts()
+                    # Convert prompts to dict
+                    return [prompt.model_dump(mode='json', exclude_none=True) for prompt in result.prompts]
+                elif method == 'prompts/get':
+                    prompt_name = params.get('name')
+                    arguments = params.get('arguments', {})
+                    result = await session.get_prompt(prompt_name, arguments)
+                    # Convert messages to dict
+                    return [message.model_dump(mode='json', exclude_none=True) for message in result.messages]
+                else:
+                    raise ValueError(f"Unsupported method: {method}")
+    finally:
+        # Clean up the http_client if we created one
+        if http_client is not None:
+            await http_client.aclose()
+
+
+
+def print_version(ctx, param, value):
+    """Print detailed version information."""
+    if not value or ctx.resilient_parsing:
+        return
+    
+    # Get Python version
+    python_version = f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+    
+    # Try to get installation path
+    try:
+        import murl
+        install_path = os.path.dirname(os.path.abspath(murl.__file__))
+    except Exception:
+        install_path = "unknown"
+    
+    click.echo(f"murl version {__version__}")
+    click.echo(f"Python {python_version}")
+    click.echo(f"Installation path: {install_path}")
+    ctx.exit()
+
+
+def run_upgrade(ctx, param, value):
+    """Run the upgrade process."""
+    if not value or ctx.resilient_parsing:
+        return
+    
+    # Repository configuration - using master branch as primary
+    github_repo_url = "https://raw.githubusercontent.com/turlockmike/murl/master/install.sh"
+    
+    try:
+        # Check if required tools are available
+        try:
+            subprocess.run(["curl", "--version"], capture_output=True, check=True)
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            click.echo("Error: curl is not installed. Please install curl and try again.", err=True)
+            ctx.exit(1)
+        
+        try:
+            subprocess.run(["bash", "--version"], capture_output=True, check=True)
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            click.echo("Error: bash is not installed. Please install bash and try again.", err=True)
+            ctx.exit(1)
+        
+        click.echo("Upgrading murl...")
+        click.echo("Downloading and running install script...")
+        
+        # Use subprocess with list arguments to avoid shell injection
+        # First download the script
+        download_result = subprocess.run(
+            ["curl", "-sSL", github_repo_url],
+            capture_output=True,
+            text=True,
+            check=False
+        )
+        
+        if download_result.returncode != 0:
+            click.echo(f"Error: Failed to download install script: {download_result.stderr}", err=True)
+            ctx.exit(1)
+        
+        # Then execute it with bash
+        result = subprocess.run(
+            ["bash"],
+            input=download_result.stdout,
+            capture_output=True,
+            text=True,
+            check=False
+        )
+        
+        if result.returncode == 0:
+            click.echo(result.stdout)
+            click.echo("✓ Upgrade complete!")
+            ctx.exit(0)
+        else:
+            click.echo(f"Error during upgrade: {result.stderr}", err=True)
+            ctx.exit(1)
+            
+    except subprocess.SubprocessError as e:
+        click.echo(f"Error: Subprocess failed: {e}", err=True)
+        ctx.exit(1)
+    except PermissionError as e:
+        click.echo(f"Error: Permission denied: {e}. You may need elevated privileges.", err=True)
+        ctx.exit(1)
+    except Exception as e:
+        click.echo(f"Error: Unexpected error during upgrade: {e}", err=True)
+        ctx.exit(1)
+
+
+@click.command()
+@click.argument('url', required=False)
+@click.option('-d', '--data', 'data_flags', multiple=True, 
+              help='Add data to the request. Format: key=value or JSON string')
+@click.option('-H', '--header', 'header_flags', multiple=True,
+              help='Add custom HTTP header. Format: "Key: Value"')
+@click.option('-v', '--verbose', is_flag=True,
+              help='Enable verbose output (prints JSON-RPC payload and HTTP headers to stderr)')
+@click.option('--version', is_flag=True, callback=print_version, expose_value=False, is_eager=True,
+              help='Show detailed version information')
+@click.option('--upgrade', is_flag=True, callback=run_upgrade, expose_value=False, is_eager=True,
+              help='Upgrade murl to the latest version')
+def main(url: Optional[str], data_flags: Tuple[str, ...], header_flags: Tuple[str, ...], verbose: bool):
+    """murl - MCP Curl: A curl-like CLI tool for Model Context Protocol (MCP) servers.
+
+    MCP (Model Context Protocol) is an open standard for AI models to access
+    external data sources and tools. murl provides a command-line interface
+    to interact with MCP servers.
+    
+    Examples:
+    
+        # List tools
+        murl http://localhost:3000/tools
+        
+        # Call a tool
+        murl http://localhost:3000/tools/echo -d message=hello
+        
+        # Call a tool with JSON data
+        murl http://localhost:3000/tools/config -d '{"theme": "dark"}'
+        
+        # Read a resource (file path)
+        murl http://localhost:3000/resources/path/to/file
+        
+        # Add authorization header
+        murl http://localhost:3000/prompts -H "Authorization: Bearer token123"
+    """
+    # If no URL is provided, show help
+    if url is None:
+        ctx = click.get_current_context()
+        click.echo(ctx.get_help())
+        ctx.exit(0)
+    
+    try:
+        # Parse URL
+        base_url, virtual_path = parse_url(url)
+        
+        # Parse data flags
+        data = parse_data_flags(data_flags) if data_flags else {}
+        
+        # Map virtual path to method and params
+        method, params = map_virtual_path_to_method(virtual_path, data)
+        
+        # Parse headers for authentication and custom HTTP headers
+        headers = parse_headers(header_flags) if header_flags else {}
+        
+        # Make the MCP request using SDK (async)
+        result = asyncio.run(make_mcp_request(base_url, method, params, headers, verbose))
+        
+        # Output the result
+        click.echo(json.dumps(result, indent=2))
+        
+    except ValueError as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+    except ConnectionError as e:
+        click.echo(f"Error: Failed to connect to {url}: {e}", err=True)
+        sys.exit(1)
+    except TimeoutError as e:
+        click.echo(f"Error: Request timeout to {url}: {e}", err=True)
+        sys.exit(1)
+    except Exception as e:
+        # Handle MCP SDK exceptions and other errors
+        error_msg = str(e)
+        if "ConnectError" in error_msg or "Connection" in error_msg:
+            click.echo(f"Error: Failed to connect to {url}", err=True)
+        elif "Timeout" in error_msg:
+            click.echo(f"Error: Request timeout to {url}", err=True)
+        elif "ValidationError" in error_msg:
+            click.echo(f"Error: Invalid response from server: {e}", err=True)
+        else:
+            click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()