httptest-cli 0.1.0__py3-none-any.whl

httptest/__init__.py

@@ -0,0 +1,3 @@
+"""httptest - Local HTTP Test Server CLI."""
+
+__version__ = "0.1.0"

httptest/cli.py

@@ -0,0 +1,651 @@
+#!/usr/bin/env python3
+"""httptest - Local HTTP Test Server CLI.
+
+Spin up test servers for development: echo requests, serve files, mock APIs.
+"""
+
+import click
+import json
+import sys
+import os
+import mimetypes
+import threading
+import time
+from datetime import datetime
+from http.server import HTTPServer, BaseHTTPRequestHandler
+from functools import partial
+from urllib.parse import urlparse, parse_qs
+from pathlib import Path
+
+__version__ = "0.1.0"
+
+
+class EchoHandler(BaseHTTPRequestHandler):
+    """Echo back request details as JSON."""
+    
+    def __init__(self, *args, record_file=None, cors=True, **kwargs):
+        self.record_file = record_file
+        self.cors = cors
+        super().__init__(*args, **kwargs)
+    
+    def log_message(self, format, *args):
+        """Suppress default logging."""
+        pass
+    
+    def _set_cors_headers(self):
+        if self.cors:
+            self.send_header("Access-Control-Allow-Origin", "*")
+            self.send_header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, PATCH, OPTIONS")
+            self.send_header("Access-Control-Allow-Headers", "*")
+    
+    def _read_body(self):
+        content_length = self.headers.get('Content-Length')
+        if content_length:
+            return self.rfile.read(int(content_length)).decode('utf-8', errors='replace')
+        return None
+    
+    def _build_response(self, method):
+        parsed = urlparse(self.path)
+        body = self._read_body() if method in ('POST', 'PUT', 'PATCH') else None
+        
+        # Try to parse JSON body
+        body_json = None
+        if body:
+            try:
+                body_json = json.loads(body)
+            except:
+                pass
+        
+        response = {
+            "timestamp": datetime.utcnow().isoformat() + "Z",
+            "method": method,
+            "path": parsed.path,
+            "query": parse_qs(parsed.query),
+            "headers": dict(self.headers),
+            "body": body_json if body_json else body,
+            "client": {
+                "address": self.client_address[0],
+                "port": self.client_address[1]
+            }
+        }
+        
+        # Record if enabled
+        if self.record_file:
+            with open(self.record_file, 'a') as f:
+                f.write(json.dumps(response) + '\n')
+        
+        return response
+    
+    def _send_json(self, data, status=200):
+        response = json.dumps(data, indent=2)
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json")
+        self._set_cors_headers()
+        self.end_headers()
+        self.wfile.write(response.encode())
+    
+    def do_OPTIONS(self):
+        self.send_response(200)
+        self._set_cors_headers()
+        self.end_headers()
+    
+    def do_GET(self):
+        self._send_json(self._build_response("GET"))
+    
+    def do_POST(self):
+        self._send_json(self._build_response("POST"))
+    
+    def do_PUT(self):
+        self._send_json(self._build_response("PUT"))
+    
+    def do_DELETE(self):
+        self._send_json(self._build_response("DELETE"))
+    
+    def do_PATCH(self):
+        self._send_json(self._build_response("PATCH"))
+
+
+class StaticHandler(BaseHTTPRequestHandler):
+    """Serve static files from a directory."""
+    
+    def __init__(self, *args, directory=".", cors=True, index="index.html", **kwargs):
+        self.directory = Path(directory).resolve()
+        self.cors = cors
+        self.index = index
+        super().__init__(*args, **kwargs)
+    
+    def log_message(self, format, *args):
+        pass
+    
+    def _set_cors_headers(self):
+        if self.cors:
+            self.send_header("Access-Control-Allow-Origin", "*")
+    
+    def do_GET(self):
+        parsed = urlparse(self.path)
+        path = parsed.path.lstrip('/')
+        
+        if not path:
+            path = self.index
+        
+        file_path = self.directory / path
+        
+        # Security: prevent directory traversal
+        try:
+            file_path = file_path.resolve()
+            if not str(file_path).startswith(str(self.directory)):
+                self.send_error(403, "Forbidden")
+                return
+        except:
+            self.send_error(400, "Bad request")
+            return
+        
+        # Check if it's a directory
+        if file_path.is_dir():
+            index_path = file_path / self.index
+            if index_path.exists():
+                file_path = index_path
+            else:
+                # List directory
+                self._list_directory(file_path)
+                return
+        
+        if not file_path.exists():
+            self.send_error(404, "Not found")
+            return
+        
+        # Serve file
+        content_type, _ = mimetypes.guess_type(str(file_path))
+        content_type = content_type or 'application/octet-stream'
+        
+        try:
+            with open(file_path, 'rb') as f:
+                content = f.read()
+            
+            self.send_response(200)
+            self.send_header("Content-Type", content_type)
+            self.send_header("Content-Length", len(content))
+            self._set_cors_headers()
+            self.end_headers()
+            self.wfile.write(content)
+        except Exception as e:
+            self.send_error(500, str(e))
+    
+    def _list_directory(self, path):
+        """Generate directory listing."""
+        try:
+            entries = sorted(path.iterdir(), key=lambda x: (not x.is_dir(), x.name.lower()))
+        except OSError:
+            self.send_error(403, "Cannot list directory")
+            return
+        
+        html = ['<!DOCTYPE html><html><head><title>Directory listing</title>',
+                '<style>body{font-family:monospace;padding:20px}',
+                'a{text-decoration:none}a:hover{text-decoration:underline}',
+                '.dir{color:#0066cc}.file{color:#333}</style></head>',
+                '<body><h1>Directory listing</h1><ul>']
+        
+        rel_path = path.relative_to(self.directory)
+        if str(rel_path) != '.':
+            html.append('<li><a href="../" class="dir">../</a></li>')
+        
+        for entry in entries:
+            name = entry.name
+            if entry.is_dir():
+                html.append(f'<li><a href="{name}/" class="dir">{name}/</a></li>')
+            else:
+                size = entry.stat().st_size
+                html.append(f'<li><a href="{name}" class="file">{name}</a> ({size} bytes)</li>')
+        
+        html.append('</ul></body></html>')
+        
+        content = '\n'.join(html).encode()
+        self.send_response(200)
+        self.send_header("Content-Type", "text/html")
+        self.send_header("Content-Length", len(content))
+        self._set_cors_headers()
+        self.end_headers()
+        self.wfile.write(content)
+    
+    def do_OPTIONS(self):
+        self.send_response(200)
+        self._set_cors_headers()
+        self.end_headers()
+
+
+class MockHandler(BaseHTTPRequestHandler):
+    """Serve mock API responses from a JSON spec file."""
+    
+    def __init__(self, *args, spec=None, cors=True, **kwargs):
+        self.spec = spec or {}
+        self.cors = cors
+        super().__init__(*args, **kwargs)
+    
+    def log_message(self, format, *args):
+        pass
+    
+    def _set_cors_headers(self):
+        if self.cors:
+            self.send_header("Access-Control-Allow-Origin", "*")
+            self.send_header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, PATCH, OPTIONS")
+            self.send_header("Access-Control-Allow-Headers", "*")
+    
+    def _find_route(self, method, path):
+        """Find matching route in spec."""
+        parsed = urlparse(path)
+        path_only = parsed.path
+        
+        # Try exact match first
+        key = f"{method} {path_only}"
+        if key in self.spec:
+            return self.spec[key]
+        
+        # Try method-agnostic match
+        if path_only in self.spec:
+            return self.spec[path_only]
+        
+        # Try wildcard routes (simple pattern matching)
+        for route_key, route_spec in self.spec.items():
+            parts = route_key.split(' ', 1)
+            if len(parts) == 2:
+                route_method, route_path = parts
+            else:
+                route_method = None
+                route_path = parts[0]
+            
+            if route_method and route_method != method:
+                continue
+            
+            # Simple wildcard matching
+            if '*' in route_path:
+                import fnmatch
+                if fnmatch.fnmatch(path_only, route_path):
+                    return route_spec
+        
+        return None
+    
+    def _handle_request(self, method):
+        route = self._find_route(method, self.path)
+        
+        if route is None:
+            self.send_response(404)
+            self.send_header("Content-Type", "application/json")
+            self._set_cors_headers()
+            self.end_headers()
+            self.wfile.write(json.dumps({"error": "Route not found", "path": self.path}).encode())
+            return
+        
+        # Handle different route spec formats
+        if isinstance(route, dict):
+            status = route.get('status', 200)
+            headers = route.get('headers', {})
+            body = route.get('body', route.get('response', {}))
+            delay = route.get('delay', 0)
+        else:
+            status = 200
+            headers = {}
+            body = route
+            delay = 0
+        
+        # Add delay if specified
+        if delay > 0:
+            time.sleep(delay / 1000.0)  # delay in ms
+        
+        # Send response
+        self.send_response(status)
+        
+        # Default to JSON
+        if 'Content-Type' not in headers:
+            headers['Content-Type'] = 'application/json'
+        
+        for key, value in headers.items():
+            self.send_header(key, value)
+        self._set_cors_headers()
+        self.end_headers()
+        
+        if isinstance(body, (dict, list)):
+            self.wfile.write(json.dumps(body, indent=2).encode())
+        else:
+            self.wfile.write(str(body).encode())
+    
+    def do_OPTIONS(self):
+        self.send_response(200)
+        self._set_cors_headers()
+        self.end_headers()
+    
+    def do_GET(self):
+        self._handle_request("GET")
+    
+    def do_POST(self):
+        self._handle_request("POST")
+    
+    def do_PUT(self):
+        self._handle_request("PUT")
+    
+    def do_DELETE(self):
+        self._handle_request("DELETE")
+    
+    def do_PATCH(self):
+        self._handle_request("PATCH")
+
+
+def create_handler(handler_class, **kwargs):
+    """Create a handler class with custom attributes."""
+    return partial(handler_class, **kwargs)
+
+
+def run_server(handler, port, host='0.0.0.0', quiet=False):
+    """Run the HTTP server."""
+    server = HTTPServer((host, port), handler)
+    if not quiet:
+        click.echo(f"Server running at http://{host}:{port}")
+        click.echo("Press Ctrl+C to stop")
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        if not quiet:
+            click.echo("\nServer stopped")
+        server.shutdown()
+
+
+@click.group()
+@click.version_option(__version__)
+def cli():
+    """httptest - Local HTTP Test Server CLI.
+    
+    Spin up test servers for development: echo requests, serve files, mock APIs.
+    """
+    pass
+
+
+@cli.command()
+@click.option('-p', '--port', default=8080, help='Port to listen on')
+@click.option('-H', '--host', default='0.0.0.0', help='Host to bind to')
+@click.option('--no-cors', is_flag=True, help='Disable CORS headers')
+@click.option('-r', '--record', type=click.Path(), help='Record requests to JSONL file')
+@click.option('-q', '--quiet', is_flag=True, help='Suppress startup message')
+def echo(port, host, no_cors, record, quiet):
+    """Echo all requests back as JSON.
+    
+    Returns request details including method, path, headers, and body.
+    Useful for debugging webhooks or API clients.
+    
+    Examples:
+    
+        httptest echo                    # Start on port 8080
+        
+        httptest echo -p 3000            # Custom port
+        
+        httptest echo -r requests.jsonl  # Record all requests
+    """
+    handler = create_handler(EchoHandler, record_file=record, cors=not no_cors)
+    run_server(handler, port, host, quiet)
+
+
+@cli.command()
+@click.argument('directory', default='.', type=click.Path(exists=True))
+@click.option('-p', '--port', default=8080, help='Port to listen on')
+@click.option('-H', '--host', default='0.0.0.0', help='Host to bind to')
+@click.option('--no-cors', is_flag=True, help='Disable CORS headers')
+@click.option('-i', '--index', default='index.html', help='Index file name')
+@click.option('-q', '--quiet', is_flag=True, help='Suppress startup message')
+def static(directory, port, host, no_cors, index, quiet):
+    """Serve static files from a directory.
+    
+    Automatically serves index.html for directories.
+    Shows directory listing if no index file.
+    
+    Examples:
+    
+        httptest static ./public         # Serve ./public
+        
+        httptest static . -p 3000        # Current dir on port 3000
+        
+        httptest static dist --index main.html
+    """
+    handler = create_handler(StaticHandler, directory=directory, cors=not no_cors, index=index)
+    if not quiet:
+        click.echo(f"Serving files from: {Path(directory).resolve()}")
+    run_server(handler, port, host, quiet)
+
+
+@cli.command()
+@click.argument('spec_file', type=click.Path(exists=True))
+@click.option('-p', '--port', default=8080, help='Port to listen on')
+@click.option('-H', '--host', default='0.0.0.0', help='Host to bind to')
+@click.option('--no-cors', is_flag=True, help='Disable CORS headers')
+@click.option('-q', '--quiet', is_flag=True, help='Suppress startup message')
+def mock(spec_file, port, host, no_cors, quiet):
+    """Serve mock API responses from a JSON spec file.
+    
+    Spec file format:
+    
+    \b
+    {
+        "GET /users": {"body": [{"id": 1, "name": "Alice"}]},
+        "POST /users": {"status": 201, "body": {"id": 2}},
+        "/health": {"body": {"status": "ok"}},
+        "GET /slow": {"body": "ok", "delay": 1000}
+    }
+    
+    Route keys can be:
+    - "METHOD /path" - match specific method
+    - "/path" - match any method
+    - "/users/*" - wildcard matching
+    
+    Response spec:
+    - body/response: response body (dict becomes JSON)
+    - status: HTTP status code (default 200)
+    - headers: custom headers dict
+    - delay: response delay in ms
+    
+    Examples:
+    
+        httptest mock api.json           # Serve mock API
+        
+        httptest mock spec.json -p 3000  # Custom port
+    """
+    try:
+        with open(spec_file) as f:
+            spec = json.load(f)
+    except json.JSONDecodeError as e:
+        click.echo(f"Error parsing spec file: {e}", err=True)
+        sys.exit(1)
+    
+    handler = create_handler(MockHandler, spec=spec, cors=not no_cors)
+    if not quiet:
+        click.echo(f"Mock API loaded from: {spec_file}")
+        click.echo(f"Routes: {len(spec)}")
+    run_server(handler, port, host, quiet)
+
+
+@cli.command()
+@click.option('-p', '--port', default=8080, help='Port to listen on')
+@click.option('-H', '--host', default='0.0.0.0', help='Host to bind to')
+@click.option('-o', '--out', default='requests.jsonl', help='Output file')
+@click.option('--no-cors', is_flag=True, help='Disable CORS headers')
+@click.option('-q', '--quiet', is_flag=True, help='Suppress startup message')
+def record(port, host, out, no_cors, quiet):
+    """Record incoming requests to a JSONL file.
+    
+    Echoes requests like 'echo' command but saves them to a file.
+    Each line is a JSON object with request details.
+    
+    Examples:
+    
+        httptest record                  # Record to requests.jsonl
+        
+        httptest record -o webhooks.jsonl  # Custom output file
+    """
+    handler = create_handler(EchoHandler, record_file=out, cors=not no_cors)
+    if not quiet:
+        click.echo(f"Recording requests to: {out}")
+    run_server(handler, port, host, quiet)
+
+
+@cli.command()
+@click.argument('input_file', type=click.Path(exists=True))
+@click.option('-t', '--target', required=True, help='Target URL base (e.g., http://localhost:3000)')
+@click.option('-d', '--delay', default=0, help='Delay between requests in ms')
+@click.option('--json', 'json_output', is_flag=True, help='Output as JSON')
+def replay(input_file, target, delay, json_output):
+    """Replay recorded requests to a target server.
+    
+    Reads a JSONL file of recorded requests and replays them
+    against a target URL.
+    
+    Examples:
+    
+        httptest replay requests.jsonl -t http://localhost:3000
+        
+        httptest replay webhooks.jsonl -t https://staging.api.com -d 100
+    """
+    import urllib.request
+    import urllib.error
+    
+    results = []
+    
+    with open(input_file) as f:
+        for line_num, line in enumerate(f, 1):
+            line = line.strip()
+            if not line:
+                continue
+            
+            try:
+                req_data = json.loads(line)
+            except json.JSONDecodeError as e:
+                click.echo(f"Line {line_num}: Invalid JSON - {e}", err=True)
+                continue
+            
+            method = req_data.get('method', 'GET')
+            path = req_data.get('path', '/')
+            body = req_data.get('body')
+            headers = req_data.get('headers', {})
+            
+            url = target.rstrip('/') + path
+            
+            # Build request
+            data = None
+            if body:
+                if isinstance(body, (dict, list)):
+                    data = json.dumps(body).encode()
+                else:
+                    data = str(body).encode()
+            
+            req = urllib.request.Request(url, data=data, method=method)
+            
+            # Add headers (skip host, content-length)
+            for key, value in headers.items():
+                if key.lower() not in ('host', 'content-length'):
+                    req.add_header(key, value)
+            
+            # Make request
+            try:
+                start = time.time()
+                response = urllib.request.urlopen(req, timeout=30)
+                duration = (time.time() - start) * 1000
+                status = response.status
+                result = {
+                    "line": line_num,
+                    "method": method,
+                    "path": path,
+                    "status": status,
+                    "duration_ms": round(duration, 2),
+                    "success": True
+                }
+            except urllib.error.HTTPError as e:
+                duration = 0
+                result = {
+                    "line": line_num,
+                    "method": method,
+                    "path": path,
+                    "status": e.code,
+                    "error": str(e.reason),
+                    "success": False
+                }
+            except Exception as e:
+                result = {
+                    "line": line_num,
+                    "method": method,
+                    "path": path,
+                    "error": str(e),
+                    "success": False
+                }
+            
+            results.append(result)
+            
+            if not json_output:
+                status_str = result.get('status', 'ERR')
+                icon = "✓" if result.get('success') else "✗"
+                click.echo(f"{icon} {method} {path} → {status_str}")
+            
+            if delay > 0:
+                time.sleep(delay / 1000.0)
+    
+    if json_output:
+        click.echo(json.dumps(results, indent=2))
+    else:
+        success = sum(1 for r in results if r.get('success'))
+        click.echo(f"\nReplayed {len(results)} requests: {success} succeeded, {len(results) - success} failed")
+
+
+@cli.command()
+@click.option('-p', '--port', default=8080, help='Port to listen on')
+@click.option('-H', '--host', default='0.0.0.0', help='Host to bind to')
+@click.option('--status', default=200, help='Response status code')
+@click.option('--body', default='ok', help='Response body')
+@click.option('--content-type', default='text/plain', help='Content-Type header')
+@click.option('-q', '--quiet', is_flag=True, help='Suppress startup message')
+def fixed(port, host, status, body, content_type, quiet):
+    """Return a fixed response for all requests.
+    
+    Simple server that returns the same response regardless of request.
+    Useful for health checks or simple testing.
+    
+    Examples:
+    
+        httptest fixed                   # Returns "ok" with 200
+        
+        httptest fixed --status 503 --body "maintenance"
+        
+        httptest fixed --body '{"status":"healthy"}' --content-type application/json
+    """
+    class FixedHandler(BaseHTTPRequestHandler):
+        def log_message(self, format, *args):
+            pass
+        
+        def _respond(self):
+            self.send_response(status)
+            self.send_header("Content-Type", content_type)
+            self.send_header("Access-Control-Allow-Origin", "*")
+            self.end_headers()
+            self.wfile.write(body.encode())
+        
+        def do_GET(self):
+            self._respond()
+        
+        def do_POST(self):
+            self._respond()
+        
+        def do_PUT(self):
+            self._respond()
+        
+        def do_DELETE(self):
+            self._respond()
+        
+        def do_OPTIONS(self):
+            self.send_response(200)
+            self.send_header("Access-Control-Allow-Origin", "*")
+            self.send_header("Access-Control-Allow-Methods", "*")
+            self.send_header("Access-Control-Allow-Headers", "*")
+            self.end_headers()
+    
+    run_server(FixedHandler, port, host, quiet)
+
+
+def main():
+    cli()
+
+
+if __name__ == "__main__":
+    main()

httptest_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,235 @@
+Metadata-Version: 2.4
+Name: httptest-cli
+Version: 0.1.0
+Summary: Local HTTP test server CLI - echo, static files, mock APIs
+Author-email: Marcus <marcus.builds.things@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/marcusbuildsthings-droid/httptest
+Project-URL: Repository, https://github.com/marcusbuildsthings-droid/httptest
+Project-URL: Issues, https://github.com/marcusbuildsthings-droid/httptest/issues
+Keywords: http,server,testing,mock,api,development,cli
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+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.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Software Development :: Testing :: Mocking
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.0
+Dynamic: license-file
+
+# httptest
+
+Local HTTP test server CLI for development. Echo requests, serve static files, or mock APIs.
+
+## Installation
+
+```bash
+pip install httptest-cli
+```
+
+## Quick Start
+
+```bash
+# Echo all requests back as JSON
+httptest echo
+
+# Serve static files
+httptest static ./public
+
+# Mock API from JSON spec
+httptest mock api.json
+
+# Record requests to file
+httptest record -o requests.jsonl
+
+# Replay recorded requests
+httptest replay requests.jsonl -t http://localhost:3000
+```
+
+## Commands
+
+### echo
+
+Echo all incoming requests back as JSON. Useful for debugging webhooks or API clients.
+
+```bash
+httptest echo                    # Start on port 8080
+httptest echo -p 3000            # Custom port
+httptest echo -r requests.jsonl  # Record all requests
+```
+
+Response format:
+```json
+{
+  "timestamp": "2026-02-04T12:00:00.000Z",
+  "method": "POST",
+  "path": "/webhook",
+  "query": {"foo": ["bar"]},
+  "headers": {"Content-Type": "application/json", ...},
+  "body": {"event": "user.created"},
+  "client": {"address": "127.0.0.1", "port": 54321}
+}
+```
+
+### static
+
+Serve static files from a directory with automatic index.html and directory listings.
+
+```bash
+httptest static ./public         # Serve ./public directory
+httptest static . -p 3000        # Current dir on port 3000
+httptest static dist --index main.html  # Custom index file
+```
+
+### mock
+
+Serve mock API responses from a JSON spec file.
+
+```bash
+httptest mock api.json
+httptest mock spec.json -p 3000
+```
+
+**Spec file format:**
+
+```json
+{
+  "GET /users": {
+    "body": [
+      {"id": 1, "name": "Alice"},
+      {"id": 2, "name": "Bob"}
+    ]
+  },
+  "POST /users": {
+    "status": 201,
+    "body": {"id": 3, "message": "Created"}
+  },
+  "GET /slow": {
+    "body": {"status": "ok"},
+    "delay": 1000
+  },
+  "/health": {
+    "body": {"status": "healthy"}
+  },
+  "GET /users/*": {
+    "body": {"id": 1, "name": "User"}
+  }
+}
+```
+
+Route keys:
+- `"METHOD /path"` - match specific HTTP method
+- `"/path"` - match any method
+- `"/path/*"` - wildcard matching
+
+Response options:
+- `body` or `response` - response body (objects become JSON)
+- `status` - HTTP status code (default: 200)
+- `headers` - custom response headers
+- `delay` - response delay in milliseconds
+
+### record
+
+Record all incoming requests to a JSONL file.
+
+```bash
+httptest record                  # Record to requests.jsonl
+httptest record -o webhooks.jsonl
+```
+
+### replay
+
+Replay recorded requests against a target server.
+
+```bash
+httptest replay requests.jsonl -t http://localhost:3000
+httptest replay webhooks.jsonl -t https://staging.api.com -d 100
+```
+
+Options:
+- `-t, --target` - Target URL base (required)
+- `-d, --delay` - Delay between requests in ms
+- `--json` - Output results as JSON
+
+### fixed
+
+Return a fixed response for all requests.
+
+```bash
+httptest fixed                   # Returns "ok" with 200
+httptest fixed --status 503 --body "maintenance"
+httptest fixed --body '{"status":"healthy"}' --content-type application/json
+```
+
+## Common Options
+
+All server commands support:
+- `-p, --port` - Port to listen on (default: 8080)
+- `-H, --host` - Host to bind to (default: 0.0.0.0)
+- `--no-cors` - Disable CORS headers
+- `-q, --quiet` - Suppress startup message
+
+## Use Cases
+
+### Webhook Development
+
+Test webhooks locally by echoing requests:
+
+```bash
+httptest echo -p 9999 -r webhooks.jsonl
+# Configure your service to send webhooks to http://localhost:9999
+```
+
+### API Prototyping
+
+Mock an API before it's built:
+
+```bash
+# api.json
+{
+  "GET /api/users": {"body": [{"id": 1, "name": "Test"}]},
+  "POST /api/users": {"status": 201, "body": {"id": 2}},
+  "GET /api/users/*": {"body": {"id": 1, "name": "User"}}
+}
+
+httptest mock api.json -p 3001
+```
+
+### Frontend Development
+
+Serve your frontend build:
+
+```bash
+httptest static ./dist -p 8000
+```
+
+### Load Testing Prep
+
+Record production traffic, then replay against staging:
+
+```bash
+# Record
+httptest record -p 8080 -o traffic.jsonl
+
+# Replay
+httptest replay traffic.jsonl -t http://staging.example.com
+```
+
+## For AI Agents
+
+See [SKILL.md](SKILL.md) for agent-optimized documentation.
+
+## License
+
+MIT

httptest_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+httptest/__init__.py,sha256=Yrn3rTLYk4eIqH_zw0gH3HNoXMZeurk_NV-A8UD5jYw,68
+httptest/cli.py,sha256=ibUKnPZv3_r71buujYeAbkAJNsykV5PqCB1S5UYE5gU,21792
+httptest_cli-0.1.0.dist-info/licenses/LICENSE,sha256=9tNBpWq8KGbuJqmeComp40OiNnbvpvsKn1YP26PUtck,1063
+httptest_cli-0.1.0.dist-info/METADATA,sha256=vD1RNz9wWu-sO_dvwYoMItr18f-egzPIXz3bGXTQRfo,5415
+httptest_cli-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+httptest_cli-0.1.0.dist-info/entry_points.txt,sha256=DC4Nu8r8MHw4sAKsxd0RgTR4Pjeq7xDptJSxX7eDjfU,47
+httptest_cli-0.1.0.dist-info/top_level.txt,sha256=cOPvre9yD0Pf88K6LRy5EtD-MI3bYJS-3UROswEQ_cc,9
+httptest_cli-0.1.0.dist-info/RECORD,,

httptest_cli-0.1.0.dist-info/WHEEL

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

httptest_cli-0.1.0.dist-info/entry_points.txt

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

httptest_cli-0.1.0.dist-info/licenses/LICENSE

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

httptest_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+httptest