proxy

type CaptureFilter func(entry *HistoryEntry) bool

type CertManager struct {
	// contains filtered or unexported fields
}

type ChunkFrame struct {
	// SizeLine is the raw size line without terminator, preserving extensions (e.g. "4;foo=bar") and hex casing.
	SizeLine []byte `json:"size_line,omitempty" msgpack:"sl,omitempty"`

	// SizeEnding is the terminator after the size line.
	SizeEnding LineEnding `json:"size_ending,omitempty" msgpack:"se,omitempty"`

	// Size is the chunk payload length in bytes (0 for final terminator chunk).
	Size int `json:"size,omitempty" msgpack:"sz,omitempty"`

	// DataEnding is the terminator after the chunk data. On the final 0-chunk it
	// is the trailer block's closing blank-line terminator, or EndingNone if truncated.
	DataEnding LineEnding `json:"data_ending,omitempty" msgpack:"de,omitempty"`

	// Malformed marks the trailing frame after a bad hex size; SizeLine holds
	// the raw bytes verbatim and the parser does not read past it.
	Malformed bool `json:"malformed,omitempty" msgpack:"mf,omitempty"`
}

type H2RequestData struct {
	// Pseudo-headers
	Method    string `json:"method" msgpack:"m"`    // from :method
	Scheme    string `json:"scheme" msgpack:"s"`    // from :scheme
	Authority string `json:"authority" msgpack:"a"` // from :authority
	Path      string `json:"path" msgpack:"p"`      // from :path

	// Regular headers (not pseudo-headers)
	Headers Headers `json:"headers" msgpack:"h"`

	// Body is the request body
	Body []byte `json:"body,omitempty" msgpack:"b,omitempty"`
}

type H2ResponseData struct {
	// StatusCode from :status pseudo-header
	StatusCode int `json:"status_code" msgpack:"sc"`

	// Regular headers (not pseudo-headers)
	Headers Headers `json:"headers" msgpack:"h"`

	// Body is the response body
	Body []byte `json:"body,omitempty" msgpack:"b,omitempty"`
}

type Header struct {
	// Name preserves original casing and whitespace anomalies
	// (e.g., "Content-Type", "content-type", or "Header " with trailing space)
	Name string `json:"name" msgpack:"n"`

	// Value is the header value with leading/trailing whitespace trimmed
	Value string `json:"value" msgpack:"v"`

	// RawLine contains the original wire bytes for this header (excluding line ending).
	// Used by SerializeRaw() to preserve exact wire format including obs-fold.
	// nil when header was programmatically created or Wire format not tracked.
	RawLine []byte `json:"raw_line,omitempty" msgpack:"rl,omitempty"`

	// LineEnding is the terminator observed for this header's final physical line.
	LineEnding LineEnding `json:"line_ending,omitempty" msgpack:"le,omitempty"`
}

type HeaderGroup struct {
	Key     string   // lowercase header name
	Entries []string // original "Name: Value" strings
}

type Headers []Header

type HistoryEntry struct {
	// Offset is the monotonic history index
	Offset uint32 `json:"offset" msgpack:"o"`

	// Protocol identifies the HTTP version: "http/1.1", "h2", or "websocket"
	Protocol string `json:"protocol" msgpack:"pr"`

	// HTTP/1.1 request/response (nil for HTTP/2)
	Request  *RawHTTP1Request  `json:"request,omitempty" msgpack:"rq,omitempty"`
	Response *RawHTTP1Response `json:"response,omitempty" msgpack:"rs,omitempty"`

	// HTTP/2 request/response (nil for HTTP/1.1)
	H2Request  *H2RequestData  `json:"h2_request,omitempty" msgpack:"h2q,omitempty"`
	H2Response *H2ResponseData `json:"h2_response,omitempty" msgpack:"h2r,omitempty"`
	H2StreamID uint32          `json:"h2_stream_id,omitempty" msgpack:"h2s,omitempty"` // for debugging/correlation

	// WSFrames contains WebSocket frames for Protocol="websocket" entries.
	// The handshake is stored in Request/Response; frames are appended here.
	WSFrames []WSFrame `json:"ws_frames,omitempty" msgpack:"ws,omitempty"`

	// Timing metadata
	Timestamp time.Time     `json:"timestamp" msgpack:"ts"`
	Duration  time.Duration `json:"duration" msgpack:"d"`
}

type HistoryMeta struct {
	Offset      uint32        `msgpack:"o"`
	Protocol    string        `msgpack:"pr"`
	Method      string        `msgpack:"m"`
	Host        string        `msgpack:"h"`
	Path        string        `msgpack:"p"` // includes query string
	Status      int           `msgpack:"s"`
	ContentType string        `msgpack:"ct"`
	RespLen     int           `msgpack:"rl"`
	H2StreamID  uint32        `msgpack:"h2,omitempty"`
	Timestamp   time.Time     `msgpack:"ts"`
	Duration    time.Duration `msgpack:"d"`
}

type HistoryStore struct {
	// contains filtered or unexported fields
}

type InterceptedResponse struct {
	StatusCode int
	Headers    Headers
	Body       []byte
}

type JSONModifier func(body []byte, setJSON map[string]any, removeJSON []string) ([]byte, error)

type LineEnding uint8

type Modifications struct {
	Method        string            // Override HTTP method
	SetHeaders    []string          // "Name: Value" format; duplicates supported
	RemoveHeaders []string          // Remove headers by name
	Body          []byte            // Replace entire body (mutually exclusive with JSON mods)
	SetJSON       map[string]any    // Modify JSON fields
	RemoveJSON    []string          // Remove JSON fields
	SetParams     map[string]string // Set query parameters
	RemoveParams  []string          // Remove query parameters
}

type ProxyServer struct {
	// contains filtered or unexported fields
}

type RawHTTP1Request struct {
	// Request line components
	Method  string `json:"method" msgpack:"m"`                    // "GET", "POST", etc.
	Path    string `json:"path" msgpack:"p"`                      // path without query string, e.g., "/path"
	Query   string `json:"query,omitempty" msgpack:"q,omitempty"` // query string without leading ?, e.g., "foo=bar"
	Version string `json:"version" msgpack:"v"`                   // "HTTP/1.1" or "HTTP/1.0"

	// Headers preserves order and original name casing/whitespace
	Headers Headers `json:"headers" msgpack:"h"`

	// Body is the request body (decoded if chunked, raw otherwise)
	// For chunked encoding, this contains the reassembled body without chunk framing
	Body []byte `json:"body,omitempty" msgpack:"b,omitempty"`

	// Trailers for chunked encoding (raw bytes, rare but must preserve)
	// TODO - FUTURE - Parse trailers into []Header if trailer rules are needed
	Trailers []byte `json:"trailers,omitempty" msgpack:"t,omitempty"`

	// Chunks preserves per-chunk wire framing for chunked messages.
	// When body is mutated, callers must set to nil to avoid stale state being re-emitted.
	Chunks []ChunkFrame `json:"chunks,omitempty" msgpack:"ck,omitempty"`

	// Protocol metadata for replay fidelity
	Protocol string `json:"protocol" msgpack:"pr"` // "http/1.1" - stored for history/replay

	// RequestLineEnding is the terminator observed on the request line.
	RequestLineEnding LineEnding `json:"request_line_ending,omitempty" msgpack:"rle,omitempty"`

	// HeaderBlockEnding is the terminator observed on the blank line that ends the header block.
	HeaderBlockEnding LineEnding `json:"header_block_ending,omitempty" msgpack:"hbe,omitempty"`

	// Wire contains metadata about the original wire encoding.
	// Used by SerializeRaw() to preserve exact wire format.
	Wire *WireFormat `json:"wire,omitempty" msgpack:"w,omitempty"`
}

type RawHTTP1Response struct {
	// Status line components
	Version    string `json:"version" msgpack:"v"`                          // "HTTP/1.1" or "HTTP/1.0"
	StatusCode int    `json:"status_code" msgpack:"sc"`                     // 200, 404, etc.
	StatusText string `json:"status_text,omitempty" msgpack:"st,omitempty"` // "OK", "Not Found", etc.

	// Headers preserves order and original name casing
	Headers Headers `json:"headers" msgpack:"h"`

	// Body is the response body (decoded if chunked, raw otherwise)
	Body []byte `json:"body,omitempty" msgpack:"b,omitempty"`

	// Trailers for chunked encoding (raw bytes)
	// TODO - FUTURE - Parse trailers into []Header if trailer rules are needed
	Trailers []byte `json:"trailers,omitempty" msgpack:"t,omitempty"`

	// Chunks preserves per-chunk wire framing for chunked messages.
	// When body is mutated, callers must set to nil to avoid stale state being re-emitted.
	Chunks []ChunkFrame `json:"chunks,omitempty" msgpack:"ck,omitempty"`

	// StatusLineEnding is the terminator observed on the status line.
	StatusLineEnding LineEnding `json:"status_line_ending,omitempty" msgpack:"sle,omitempty"`

	// HeaderBlockEnding is the terminator observed on the blank line that ends the header block.
	HeaderBlockEnding LineEnding `json:"header_block_ending,omitempty" msgpack:"hbe,omitempty"`

	// Wire contains metadata about the original wire encoding.
	// Used by SerializeRaw() to preserve exact wire format.
	Wire *WireFormat `json:"wire,omitempty" msgpack:"w,omitempty"`
}

type ResponseInterceptor interface {
	// InterceptRequest checks if a request matches a registered responder.
	// host is the target hostname (lowercase), port is the target port,
	// path is the URL path (query string stripped), method is the HTTP method.
	// Returns the response to serve, or nil if no match.
	InterceptRequest(host string, port int, path string, method string) *InterceptedResponse
}

type RuleApplier interface {
	// ApplyRequestRules applies request header and body rules.
	// Returns the modified request (may be same instance if no changes).
	ApplyRequestRules(req *RawHTTP1Request) *RawHTTP1Request

	// ApplyResponseRules applies response header and body rules.
	// Handles decompression/recompression for body rules.
	ApplyResponseRules(resp *RawHTTP1Response) *RawHTTP1Response

	// ApplyRequestBodyOnlyRules applies only body rules to a request body.
	// Used by HTTP/2 where headers are sent separately before body.
	// Requires headers for Content-Encoding detection (compression-aware).
	// Does not apply header rules.
	// Returns error if recompression fails (caller should reset stream).
	ApplyRequestBodyOnlyRules(body []byte, headers Headers) ([]byte, error)

	// ApplyResponseBodyOnlyRules applies only body rules to a response body.
	// Used by HTTP/2 where headers are sent separately before body.
	// Requires headers for Content-Encoding detection (compression-aware).
	// Does not apply header rules.
	ApplyResponseBodyOnlyRules(body []byte, headers Headers) []byte

	// ApplyWSRules applies WebSocket rules to frame payload.
	// direction is "ws:to-server" or "ws:to-client".
	ApplyWSRules(payload []byte, direction string) []byte

	// HasBodyRules returns true if there are body rules for request or response.
	// Used by HTTP/2 handler to decide whether to buffer full bodies.
	// isRequest=true checks for request_body rules, false checks for response_body rules.
	HasBodyRules(isRequest bool) bool
}

type SendOptions struct {
	RawRequest    []byte         // Raw HTTP request bytes
	Target        Target         // Where to send
	Modifications *Modifications // Optional changes
	Force         bool           // Bypass validation

	// Protocol specifies the original request's protocol.
	// Values: "http/1.1", "h2", or "" (defaults to http/1.1)
	// When "h2", the sender will negotiate HTTP/2 with the server.
	Protocol string
}

type SendResult struct {
	Response *RawHTTP1Response
	Duration time.Duration
}

type Sender struct {
	// JSONModifier is called to apply JSON modifications to request body.
	// If nil, SetJSON/RemoveJSON modifications are ignored.
	JSONModifier JSONModifier

	// RequestRuleApplier applies find/replace rules to each request before sending.
	// Called for every request including redirect hops. If nil, no rules are applied.
	RequestRuleApplier func(req *RawHTTP1Request) *RawHTTP1Request

	// Timeouts holds configurable timeout values for dial, read, and write.
	// Zero values mean no timeout.
	Timeouts TimeoutConfig
}

type Target struct {
	Hostname  string
	Port      int
	UsesHTTPS bool
}

type TimeoutConfig struct {
	DialTimeout  time.Duration
	ReadTimeout  time.Duration
	WriteTimeout time.Duration
}

type WSFrame struct {
	// Direction is "to-server" or "to-client"
	Direction string `json:"direction" msgpack:"dr"`

	// Opcode is the WebSocket opcode (1=text, 2=binary, 8=close, 9=ping, 10=pong)
	Opcode byte `json:"opcode" msgpack:"op"`

	// Payload is the frame payload (unmasked)
	Payload []byte `json:"payload,omitempty" msgpack:"pl,omitempty"`

	// Timestamp when the frame was captured
	Timestamp time.Time `json:"timestamp" msgpack:"ts"`
}

type WireFormat struct {
	// WasChunked indicates chunked transfer encoding was received.
	WasChunked bool `json:"was_chunked,omitempty" msgpack:"wc,omitempty"`

	// UsedBareLF is true when any line used bare LF (\n) as terminator.
	UsedBareLF bool `json:"used_bare_lf,omitempty" msgpack:"lf,omitempty"`

	// UsedBareCR is true when any line used bare CR (\r) as terminator.
	UsedBareCR bool `json:"used_bare_cr,omitempty" msgpack:"cr,omitempty"`
}