httpx-mcp 1.0.0__tar.gz

httpx_mcp-1.0.0/PKG-INFO

@@ -0,0 +1,164 @@
+Metadata-Version: 2.4
+Name: httpx-mcp
+Version: 1.0.0
+Summary: A MCP tool for HTTP request testing using httpx
+Author-email: ZHEFOX <zhefox@outlook.com>
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: mcp>=1.0.0
+Description-Content-Type: text/markdown
+
+# HTTPX MCP
+
+An MCP tool for HTTP interface testing, built on the httpx library, designed for AI.
+
+## Features
+
+- 🚀 **Full HTTP Method Support**: GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS
+- 📝 **Multiple Request Formats**: JSON, form data, raw text
+- 🔧 **Custom Headers**: Support for arbitrary HTTP headers
+- 📋 **Raw Request Parsing**: Directly paste Burp Suite captured requests
+- ⏱️ **Response Details**: Status code, response headers, response body, timing statistics
+- 🔒 **SSL Control**: Optional SSL certificate verification
+
+## Installation
+
+```bash
+cd httpx-mcp
+pip install -e .
+```
+
+## MCP Configuration
+
+Add to your MCP configuration file:
+
+```json
+{
+  "mcpServers": {
+    "httpx-mcp": {
+      "command": "python",
+      "args": ["-m", "httpx_mcp.server"],
+      "cwd": "c:/Users/ZHEFOX/Desktop/mcptools/httpx-mcp"
+    }
+  }
+}
+```
+
+Or use directly after installation:
+
+```json
+{
+  "mcpServers": {
+    "httpx-mcp": {
+      "command": "httpx-mcp"
+    }
+  }
+}
+```
+
+## Available Tools
+
+### 1. `http_request` - General HTTP Request
+
+Send any HTTP request, switch request method via the `method` parameter.
+
+**Parameters:**
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `url` | string | ✅ | - | Full URL |
+| `method` | string | - | GET | HTTP method: GET/POST/PUT/DELETE/PATCH/HEAD/OPTIONS |
+| `params` | string | - | - | URL query parameters, JSON or key=value format |
+| `headers` | string | - | - | Request headers, JSON format |
+| `body` | string | - | - | Request body |
+| `content_type` | string | - | application/json | Content-Type |
+| `timeout` | number | - | 30 | Timeout in seconds |
+| `follow_redirects` | boolean | - | true | Whether to follow redirects |
+| `verify_ssl` | boolean | - | true | Whether to verify SSL |
+| `include_headers` | boolean | - | true | Whether response includes headers |
+
+**Examples:**
+
+```
+# GET request
+method="GET", url="https://httpbin.org/get"
+
+# GET with query parameters
+method="GET", url="https://httpbin.org/get", params='{"page": "1", "size": "10"}'
+
+# POST JSON
+method="POST", url="https://httpbin.org/post", body='{"name": "test", "value": 123}'
+
+# PUT update
+method="PUT", url="https://httpbin.org/put", body='{"id": 1, "name": "updated"}'
+
+# DELETE
+method="DELETE", url="https://httpbin.org/delete"
+
+# With authentication header
+method="GET", url="https://api.example.com/users", headers='{"Authorization": "Bearer token123"}'
+
+# POST form
+method="POST", url="https://httpbin.org/post", body="username=admin&password=123", content_type="application/x-www-form-urlencoded"
+
+# Disable SSL verification
+method="GET", url="https://self-signed.example.com", verify_ssl=false
+```
+
+### 2. `http_raw` - Raw HTTP Request
+
+Directly parse raw HTTP requests captured by tools like Burp Suite.
+
+**Parameters:**
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `raw_request` | string | ✅ | - | Raw HTTP request text |
+| `base_url` | string | - | - | Base URL (if request doesn't contain full URL) |
+| `verify_ssl` | boolean | - | true | Whether to verify SSL |
+
+**Example:**
+
+```
+raw_request="""
+POST /api/login HTTP/1.1
+Host: example.com
+Content-Type: application/json
+Cookie: session=abc123
+
+{"username":"admin","password":"123456"}
+"""
+base_url="https://example.com"
+```
+
+## Response Format
+
+The tool returns formatted response information:
+
+```
+HTTP/1.1 200 OK
+
+=== Response Headers ===
+content-type: application/json
+date: Mon, 01 Jan 2024 00:00:00 GMT
+...
+
+=== Response Body ===
+{
+  "result": "success",
+  "data": {...}
+}
+
+=== Request Info ===
+Time: 0.234s
+Size: 1024 bytes
+```
+
+## Use Cases
+
+1. **API Testing**: Quickly test REST API endpoints
+2. **Security Testing**: Send custom payloads for security testing
+3. **Interface Debugging**: View detailed request/response information
+4. **Request Replay**: Directly use Burp captured content to replay requests
+
+## License
+
+MIT

httpx_mcp-1.0.0/README.md

@@ -0,0 +1,154 @@
+# HTTPX MCP
+
+An MCP tool for HTTP interface testing, built on the httpx library, designed for AI.
+
+## Features
+
+- 🚀 **Full HTTP Method Support**: GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS
+- 📝 **Multiple Request Formats**: JSON, form data, raw text
+- 🔧 **Custom Headers**: Support for arbitrary HTTP headers
+- 📋 **Raw Request Parsing**: Directly paste Burp Suite captured requests
+- ⏱️ **Response Details**: Status code, response headers, response body, timing statistics
+- 🔒 **SSL Control**: Optional SSL certificate verification
+
+## Installation
+
+```bash
+cd httpx-mcp
+pip install -e .
+```
+
+## MCP Configuration
+
+Add to your MCP configuration file:
+
+```json
+{
+  "mcpServers": {
+    "httpx-mcp": {
+      "command": "python",
+      "args": ["-m", "httpx_mcp.server"],
+      "cwd": "c:/Users/ZHEFOX/Desktop/mcptools/httpx-mcp"
+    }
+  }
+}
+```
+
+Or use directly after installation:
+
+```json
+{
+  "mcpServers": {
+    "httpx-mcp": {
+      "command": "httpx-mcp"
+    }
+  }
+}
+```
+
+## Available Tools
+
+### 1. `http_request` - General HTTP Request
+
+Send any HTTP request, switch request method via the `method` parameter.
+
+**Parameters:**
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `url` | string | ✅ | - | Full URL |
+| `method` | string | - | GET | HTTP method: GET/POST/PUT/DELETE/PATCH/HEAD/OPTIONS |
+| `params` | string | - | - | URL query parameters, JSON or key=value format |
+| `headers` | string | - | - | Request headers, JSON format |
+| `body` | string | - | - | Request body |
+| `content_type` | string | - | application/json | Content-Type |
+| `timeout` | number | - | 30 | Timeout in seconds |
+| `follow_redirects` | boolean | - | true | Whether to follow redirects |
+| `verify_ssl` | boolean | - | true | Whether to verify SSL |
+| `include_headers` | boolean | - | true | Whether response includes headers |
+
+**Examples:**
+
+```
+# GET request
+method="GET", url="https://httpbin.org/get"
+
+# GET with query parameters
+method="GET", url="https://httpbin.org/get", params='{"page": "1", "size": "10"}'
+
+# POST JSON
+method="POST", url="https://httpbin.org/post", body='{"name": "test", "value": 123}'
+
+# PUT update
+method="PUT", url="https://httpbin.org/put", body='{"id": 1, "name": "updated"}'
+
+# DELETE
+method="DELETE", url="https://httpbin.org/delete"
+
+# With authentication header
+method="GET", url="https://api.example.com/users", headers='{"Authorization": "Bearer token123"}'
+
+# POST form
+method="POST", url="https://httpbin.org/post", body="username=admin&password=123", content_type="application/x-www-form-urlencoded"
+
+# Disable SSL verification
+method="GET", url="https://self-signed.example.com", verify_ssl=false
+```
+
+### 2. `http_raw` - Raw HTTP Request
+
+Directly parse raw HTTP requests captured by tools like Burp Suite.
+
+**Parameters:**
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `raw_request` | string | ✅ | - | Raw HTTP request text |
+| `base_url` | string | - | - | Base URL (if request doesn't contain full URL) |
+| `verify_ssl` | boolean | - | true | Whether to verify SSL |
+
+**Example:**
+
+```
+raw_request="""
+POST /api/login HTTP/1.1
+Host: example.com
+Content-Type: application/json
+Cookie: session=abc123
+
+{"username":"admin","password":"123456"}
+"""
+base_url="https://example.com"
+```
+
+## Response Format
+
+The tool returns formatted response information:
+
+```
+HTTP/1.1 200 OK
+
+=== Response Headers ===
+content-type: application/json
+date: Mon, 01 Jan 2024 00:00:00 GMT
+...
+
+=== Response Body ===
+{
+  "result": "success",
+  "data": {...}
+}
+
+=== Request Info ===
+Time: 0.234s
+Size: 1024 bytes
+```
+
+## Use Cases
+
+1. **API Testing**: Quickly test REST API endpoints
+2. **Security Testing**: Send custom payloads for security testing
+3. **Interface Debugging**: View detailed request/response information
+4. **Request Replay**: Directly use Burp captured content to replay requests
+
+## License
+
+MIT

httpx_mcp-1.0.0/httpx_mcp/__init__.py

@@ -0,0 +1,3 @@
+"""HTTPX MCP - A MCP tool for HTTP request testing using httpx."""
+
+__version__ = "1.0.0"

httpx_mcp-1.0.0/httpx_mcp/server.py

@@ -0,0 +1,362 @@
+"""
+HTTPX MCP Server - HTTP Request Testing Tool
+
+Provides the following MCP tools:
+- http_request: Send HTTP requests (GET, POST, PUT, DELETE, PATCH, etc.)
+- http_raw: Parse raw HTTP requests (supports Burp Suite capture format)
+"""
+
+import json
+import sys
+from typing import Any
+
+import httpx
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+from mcp.types import Tool, TextContent
+
+# Create MCP server
+server = Server("httpx-mcp")
+
+
+def format_response(response: httpx.Response, include_headers: bool = True) -> str:
+    """Format HTTP response into a readable string"""
+    result_parts = []
+    
+    # Status line
+    result_parts.append(f"HTTP/{response.http_version} {response.status_code} {response.reason_phrase}")
+    result_parts.append("")
+    
+    # Response headers
+    if include_headers:
+        result_parts.append("=== Response Headers ===")
+        for name, value in response.headers.items():
+            result_parts.append(f"{name}: {value}")
+        result_parts.append("")
+    
+    # Response body
+    result_parts.append("=== Response Body ===")
+    
+    content_type = response.headers.get("content-type", "")
+    body = response.text
+    
+    # Try to format JSON
+    if "application/json" in content_type:
+        try:
+            parsed = json.loads(body)
+            body = json.dumps(parsed, indent=2, ensure_ascii=False)
+        except json.JSONDecodeError:
+            pass
+    
+    result_parts.append(body)
+    
+    # Add response time
+    result_parts.append("")
+    result_parts.append(f"=== Request Info ===")
+    result_parts.append(f"Time: {response.elapsed.total_seconds():.3f}s")
+    result_parts.append(f"Size: {len(response.content)} bytes")
+    
+    return "\n".join(result_parts)
+
+
+def parse_headers(headers_input: str | dict | list | None) -> dict:
+    """Parse request headers, supports multiple formats"""
+    if headers_input is None:
+        return {}
+    
+    if isinstance(headers_input, dict):
+        return headers_input
+    
+    if isinstance(headers_input, list):
+        result = {}
+        for item in headers_input:
+            if isinstance(item, str) and ":" in item:
+                key, value = item.split(":", 1)
+                result[key.strip()] = value.strip()
+            elif isinstance(item, dict):
+                result.update(item)
+        return result
+    
+    if isinstance(headers_input, str):
+        # Try to parse as JSON
+        try:
+            parsed = json.loads(headers_input)
+            if isinstance(parsed, dict):
+                return parsed
+            elif isinstance(parsed, list):
+                return parse_headers(parsed)
+        except json.JSONDecodeError:
+            pass
+        
+        # Parse line by line "Key: Value" format
+        result = {}
+        for line in headers_input.strip().split("\n"):
+            line = line.strip()
+            if ":" in line:
+                key, value = line.split(":", 1)
+                result[key.strip()] = value.strip()
+        return result
+    
+    return {}
+
+
+def parse_params(params_input: str | dict | None) -> dict | None:
+    """Parse URL query parameters"""
+    if params_input is None:
+        return None
+    
+    if isinstance(params_input, dict):
+        return params_input
+    
+    if isinstance(params_input, str):
+        try:
+            return json.loads(params_input)
+        except json.JSONDecodeError:
+            # Parse key=value&key2=value2 format
+            result = {}
+            for pair in params_input.split("&"):
+                if "=" in pair:
+                    key, value = pair.split("=", 1)
+                    result[key.strip()] = value.strip()
+            return result if result else None
+    
+    return None
+
+
+@server.list_tools()
+async def list_tools() -> list[Tool]:
+    """List all available MCP tools"""
+    return [
+        Tool(
+            name="http_request",
+            description="""Send HTTP request to specified URL. Supports all HTTP methods (GET/POST/PUT/DELETE/PATCH, etc.).
+
+Usage examples:
+- GET request: method="GET", url="https://api.example.com/users"
+- GET with params: method="GET", url="...", params='{"page":"1","size":"10"}'
+- POST JSON: method="POST", url="...", body='{"key":"value"}'
+- PUT update: method="PUT", url="...", body='{"id":1,"name":"test"}'
+- DELETE: method="DELETE", url="https://api.example.com/users/1"
+- Custom headers: headers='{"Authorization":"Bearer xxx"}'
+- Form submit: body="name=test&age=18", content_type="application/x-www-form-urlencoded" """,
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "method": {
+                        "type": "string",
+                        "description": "HTTP method: GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS",
+                        "enum": ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"],
+                        "default": "GET"
+                    },
+                    "url": {
+                        "type": "string",
+                        "description": "Full URL for the request"
+                    },
+                    "params": {
+                        "type": "string",
+                        "description": "URL query parameters, JSON format or key=value&key2=value2 format"
+                    },
+                    "headers": {
+                        "type": "string",
+                        "description": "Request headers, JSON format, e.g.: {\"Authorization\": \"Bearer xxx\"}"
+                    },
+                    "body": {
+                        "type": "string",
+                        "description": "Request body, can be JSON string, form data, or raw text"
+                    },
+                    "content_type": {
+                        "type": "string",
+                        "description": "Content-Type, e.g.: application/json, application/x-www-form-urlencoded",
+                        "default": "application/json"
+                    },
+                    "timeout": {
+                        "type": "number",
+                        "description": "Request timeout in seconds",
+                        "default": 30
+                    },
+                    "follow_redirects": {
+                        "type": "boolean",
+                        "description": "Whether to follow redirects",
+                        "default": True
+                    },
+                    "verify_ssl": {
+                        "type": "boolean",
+                        "description": "Whether to verify SSL certificate",
+                        "default": True
+                    },
+                    "include_headers": {
+                        "type": "boolean",
+                        "description": "Whether to include response headers in the output",
+                        "default": True
+                    }
+                },
+                "required": ["url"]
+            }
+        ),
+        Tool(
+            name="http_raw",
+            description="""Send raw HTTP request. Supports pasting request format directly from Burp Suite or other capture tools.
+
+Raw request format example:
+POST /api/login HTTP/1.1
+Host: example.com
+Content-Type: application/json
+
+{"username":"admin","password":"123"}""",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "raw_request": {
+                        "type": "string",
+                        "description": "Raw HTTP request text (including request line, headers, blank line, body)"
+                    },
+                    "base_url": {
+                        "type": "string",
+                        "description": "Base URL (if raw_request doesn't contain full URL), e.g.: https://example.com"
+                    },
+                    "verify_ssl": {
+                        "type": "boolean",
+                        "description": "Whether to verify SSL certificate",
+                        "default": True
+                    }
+                },
+                "required": ["raw_request"]
+            }
+        )
+    ]
+
+
+@server.call_tool()
+async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
+    """Execute MCP tool call"""
+    try:
+        if name == "http_request":
+            return await handle_http_request(arguments)
+        elif name == "http_raw":
+            return await handle_http_raw(arguments)
+        else:
+            return [TextContent(type="text", text=f"Unknown tool: {name}")]
+    except Exception as e:
+        return [TextContent(type="text", text=f"Error: {type(e).__name__}: {str(e)}")]
+
+
+async def handle_http_request(args: dict[str, Any]) -> list[TextContent]:
+    """Handle general HTTP request"""
+    method = args.get("method", "GET").upper()
+    url = args["url"]
+    params = parse_params(args.get("params"))
+    headers = parse_headers(args.get("headers"))
+    body = args.get("body")
+    content_type = args.get("content_type", "application/json")
+    timeout = args.get("timeout", 30)
+    follow_redirects = args.get("follow_redirects", True)
+    verify_ssl = args.get("verify_ssl", True)
+    include_headers = args.get("include_headers", True)
+    
+    # Set Content-Type
+    if body and "content-type" not in {k.lower() for k in headers}:
+        headers["Content-Type"] = content_type
+    
+    async with httpx.AsyncClient(
+        timeout=timeout,
+        follow_redirects=follow_redirects,
+        verify=verify_ssl
+    ) as client:
+        response = await client.request(
+            method=method,
+            url=url,
+            params=params,
+            headers=headers,
+            content=body.encode() if body else None
+        )
+        
+        result = format_response(response, include_headers)
+        return [TextContent(type="text", text=result)]
+
+
+def parse_raw_request(raw: str, base_url: str | None = None) -> tuple[str, str, dict, str | None]:
+    """Parse raw HTTP request text"""
+    lines = raw.strip().replace("\r\n", "\n").split("\n")
+    
+    # Parse request line
+    request_line = lines[0]
+    parts = request_line.split()
+    method = parts[0].upper()
+    path = parts[1] if len(parts) > 1 else "/"
+    
+    # Parse request headers
+    headers = {}
+    body_start = len(lines)
+    
+    for i, line in enumerate(lines[1:], 1):
+        if line.strip() == "":
+            body_start = i + 1
+            break
+        if ":" in line:
+            key, value = line.split(":", 1)
+            headers[key.strip()] = value.strip()
+    
+    # Parse request body
+    body = None
+    if body_start < len(lines):
+        body = "\n".join(lines[body_start:])
+    
+    # Build full URL
+    if path.startswith("http://") or path.startswith("https://"):
+        url = path
+    else:
+        host = headers.get("Host", "")
+        if base_url:
+            url = base_url.rstrip("/") + path
+        elif host:
+            # Determine protocol based on SSL-related headers
+            protocol = "https" if "443" in host else "http"
+            url = f"{protocol}://{host}{path}"
+        else:
+            url = path
+    
+    return method, url, headers, body
+
+
+async def handle_http_raw(args: dict[str, Any]) -> list[TextContent]:
+    """Handle raw HTTP request"""
+    raw_request = args["raw_request"]
+    base_url = args.get("base_url")
+    verify_ssl = args.get("verify_ssl", True)
+    
+    method, url, headers, body = parse_raw_request(raw_request, base_url)
+    
+    async with httpx.AsyncClient(
+        timeout=30,
+        follow_redirects=True,
+        verify=verify_ssl
+    ) as client:
+        response = await client.request(
+            method=method,
+            url=url,
+            headers=headers,
+            content=body.encode() if body else None
+        )
+        
+        result = format_response(response)
+        return [TextContent(type="text", text=result)]
+
+
+async def run_server():
+    """Run MCP server"""
+    async with stdio_server() as (read_stream, write_stream):
+        await server.run(
+            read_stream,
+            write_stream,
+            server.create_initialization_options()
+        )
+
+
+def main():
+    """Main entry point"""
+    import asyncio
+    asyncio.run(run_server())
+
+
+if __name__ == "__main__":
+    main()

httpx_mcp-1.0.0/pyproject.toml

@@ -0,0 +1,23 @@
+[project]
+name = "httpx-mcp"
+version = "1.0.0"
+description = "A MCP tool for HTTP request testing using httpx"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "mcp>=1.0.0",
+    "httpx>=0.27.0",
+]
+authors = [
+    {name = "ZHEFOX", email = "zhefox@outlook.com"},
+]
+
+[project.scripts]
+httpx-mcp = "httpx_mcp.server:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["httpx_mcp"]