proxy

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

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"`
}

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 JSONModifier func(body []byte, setJSON map[string]any, removeJSON []string) ([]byte, error)

type Modifications struct {
	Method        string            // Override HTTP method
	SetHeaders    map[string]string // Add or replace headers
	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"`

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

	// 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"`

	// 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 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

	// 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 the body was received with chunked transfer encoding.
	// When true, SerializeRaw can optionally re-emit chunked encoding.
	WasChunked bool `json:"was_chunked,omitempty" msgpack:"wc,omitempty"`

	// UsedBareLF indicates the message used bare LF (\n) instead of CRLF (\r\n).
	// When true, SerializeRaw uses bare LF for line endings.
	UsedBareLF bool `json:"used_bare_lf,omitempty" msgpack:"lf,omitempty"`
}