eger-geger/FryProxy

FryProxy is an asynchronous HTTP reverse proxy library for .NET 8 that manages client and upstream connections through a composable middleware pipeline. It supports standard HTTP/1.0 and HTTP/1.1 traffic, including SSL tunneling and header compression via HPACK for HTTP/2. The system provides robust features for connection pooling, request parsing, and transparent SSL interception, with a demo application illustrating its usage.

5 changes.

This period covers the initial release of the FryProxy HTTP reverse proxy library, establishing its asynchronous request processing pipeline and F\# extension modules. Significant work focused on implementing a robust, struct-based HTTP/1.0 and 1.1 parser to handle complex traffic formats, accompanied by comprehensive unit tests to verify parsing logic and utility functions.

14 changes.

This period focused on the initial development and stabilization of the FryProxy HTTP proxy library, introducing core features such as SSL tunneling, async I/O with connection pooling, and a structured middleware pipeline. Significant effort was dedicated to implementing robust HTTP/1.1 parsing logic and adding HPACK support for HTTP/2 header compression. Comprehensive test suites were built to validate the proxy's behavior, including integration tests for proxy modes and unit tests for low-level IO and parsing components.

A new demo application (Program.cs) has been added to the FryProxy.Demo project, providing a concrete example of how to initialize and run an HTTP proxy using the FryProxy library. The demo configures an HttpProxy with a default context, sets up a logging handler to print request and response details to the console, and starts the proxy service, serving as a practical reference for users integrating the library.

FryProxy.Demo · high confidence

Introduces FryProxy, an RFC-compatible HTTP reverse proxy library built on a composable, asynchronous request processing pipeline. The library allows users to define custom request handlers that can inspect or modify traffic, support for decrypting tunneled (HTTPS) traffic, and an outgoing connection pool. It targets .NET 8 and includes a demo application and unit tests to demonstrate usage.

(repo-wide) · high confidence

This change introduces the core FryProxy library, providing an HTTP proxy server capable of handling standard HTTP requests and establishing SSL tunnels (CONNECT method) for encrypted traffic. The implementation includes a connection pool for managing upstream and client connections, configurable settings for timeouts and buffer sizes, and middleware for handling Via headers and Max-Forwards fields. It also features a ProxyClient module for executing requests through the proxy and a Certificate module for generating self-signed certificates to facilitate transparent SSL interception.

FryProxy · high confidence

Added a new HPACK implementation in the FryProxy/Http/Hpack module to handle HTTP/2 header compression and decompression. This includes a decoder that processes binary command blocks, a static table of standard HTTP headers, and a dynamic table for indexing fields. The encoder supports literal and indexed fields, numeric literals, and Huffman-encoded strings, enabling the proxy to correctly compress and decompress HTTP/2 headers.

FryProxy/Http/Hpack · high confidence

The proxy now enforces timeouts on stream read and write operations via a new \AsyncTimeoutDecorator\ that raises specific exceptions when limits are exceeded, and implements a \ConnectionPool\ to manage and reuse outgoing TCP connections. This pool tracks connection idle time, automatically closes passive connections after a specified timeout, and manages resource cleanup, while supporting buffer-based reading through new \ReadBuffer\ and byte buffer utilities.

FryProxy/IO · high confidence

Added four new F\# extension modules (Error, Option, Stream, Task) to the FryProxy/Extension library. These provide utility functions such as preserving stack traces on re-thrown exceptions, converting between Option and ValueOption types, waiting for stream input with optional timeouts, and converting Tasks to ValueTasks or unit tasks.

FryProxy/Extension · high confidence

The proxy now includes structured models and parsers for several HTTP header fields, including Connection, Via, Host, Content-Type, Content-Length, Expect, Max-Forwards, and Transfer-Encoding. This enables more robust handling of HTTP/1.1 features such as persistent connections (via the Connection header's keep-alive/close semantics), hop-by-hop tracking (Via), and standard request/response metadata. The Connection field specifically supports determining connection persistence based on HTTP version and header values, while the Via field allows appending proxy hop information.

FryProxy/Http/Fields · high confidence

The proxy's request processing logic has been restructured into a modular pipeline located in the \FryProxy/Pipeline\ namespace. This change introduces a chain-of-responsibility pattern where requests pass through configurable middleware (such as \Via\, \Max-Forwards\, and \Expect\ handling) before reaching the core reverse proxy handler. It replaces mutable reference passing with a typed \ContextualResponse\ object to explicitly manage connection persistence flags (keep-alive states for client and upstream connections) and tunnel state. Additionally, it adds robust error handling that maps internal failures to specific HTTP status codes (e.g., 502 Bad Gateway, 504 Gateway Timeout) and formats error responses for the client.

FryProxy/Pipeline · high confidence

The \FryProxy/Http\ module now provides a complete, struct-based model for HTTP messages (requests and responses) along with a buffered parser capable of handling chunked transfer encoding, folded headers, and both HTTP/1.0 and HTTP/1.1 protocols. This change replaces previous primitive types with structured records for start lines, headers, and bodies, enabling the proxy to correctly parse, serialize, and forward HTTP traffic including complex body formats.

FryProxy/Http · high confidence

The proxy now includes a new \BufferedParser\ module in \FryProxy/IO/BufferedParser\ that handles the parsing of HTTP request messages from buffered streams. This implementation introduces a discriminated union state machine (\ParseState\) to manage running and yielded states, allowing for lazy evaluation of parsed content via \IAsyncEnumerable\. Key features include a \BufferedParserBuilder\ for expression-based composition, a \LazyIter\ for efficient iteration over parsed results without eager materialization, and specific parsers for handling chunked bodies and typed headers. This change replaces the previous parsing logic with a more robust, state-driven approach that supports partial reads and better memory management through \ValueTask\ and \ReadBuffer\ integration.

FryProxy/IO/BufferedParser · high confidence

Added HPACK encoding and decoding tests; Added integration tests for HTTP proxy functionality; Added test constraints for HTTP response validation and async exception checking; Added test infrastructure for FryProxy; Added tests for IO utilities, connection pooling, and buffering; Added tests for Option.ofAttempt; Added unit tests for HTTP connection persistence and field model logic; Added unit tests for HTTP request parsing and field handling; Added unit tests for proxy pipeline middleware.

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 55 → 54 (-0.7)
• Rubric changed (rubric-2026.09.15 → rubric-2026.10.1) — scores are not directly comparable.

• Code Health 100 → 100 (+0.0)
• Architecture 96 → 100 (+3.8)
• Maturity 45 → 43 (-2.1)
• Readiness 49 → 49 (+0.0)
• Security 59 → 59 (+0.0)

• Documentation: no installation or build instructions (README.md)
• Documentation: no licence statement (README.md)
• Documentation: no usage examples (README.md)

• Documentation: no project overview (README.md)

• Unchanged — 1 containers · 0 contexts · 0 edges

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

eger-geger/FryProxy was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.