From 8d15c2e0b326933f8fc912e3b13f37e78a9bc0b6 Mon Sep 17 00:00:00 2001
From: srdusr <99972264+srdusr@users.noreply.github.com>
Date: Wed, 14 Feb 2024 00:37:00 +0200
Subject: History view: SQLite storage, daemon/TUI split over Unix socket

Implements build-order step 3. Adds:

- internal/store: SQLite (WAL, single-writer) history table, raw
  request/response blobs plus metadata for the list view.
- internal/proxy: request/response capture wired into forward(). HTTP/1.1
  legs are captured byte-exact via a teeConn that records wire bytes as
  they're read, taken right after the message is fully drained (so no
  manual re-reading/replaying is needed - RoundTrip's own streaming does
  the draining). HTTP/2 legs (no meaningful "raw bytes" of their own -
  multiplexed, HPACK-compressed framing) are reconstructed instead, and
  marked as such in storage.
- internal/ipc: JSON-over-Unix-socket protocol between mitmuxd (owns the
  proxy and the DB) and any client - list/get for queries, subscribe for
  a live push stream of newly captured entries. Keeps the proxy engine
  independent of the UI, per the architecture sketch.
- cmd/mitmux: Bubble Tea TUI - a live-updating history table and a
  request/response detail view with raw bytes.

Two real bugs surfaced during testing and got fixed before commit:
1. http.Transport's HTTP/2 auto-dispatch does a literal *tls.Conn type
   assertion on the dialed connection; wrapping it in a capturing teeConn
   broke that silently, and HTTP/2 framing got parsed as HTTP/1.1 text.
   Fixed by dropping http.Transport for the upstream leg entirely in
   favor of an explicit per-protocol round trip (see PLAN.md stack note).
2. singleConnListener wrapped the client teeConn *inside* a
   closeSignalConn, so ConnContext's type assertion for it silently
   failed and HTTP/1.1 client-side capture never activated. Fixed the
   wrap order; verified via direct SQLite inspection that request_exact
   flips back to 1 and the stored bytes are genuinely wire-exact
   (preserved chunked-encoding framing, original header casing/order).

Verified live: plain HTTP, HTTPS H1.1, HTTPS H2, and a POST with a body,
checked against the raw stored bytes directly in SQLite; IPC list/get/
subscribe against a throwaway client; and the TUI driven end-to-end in a
tmux session (list, detail view, tab between request/response, live
update on a new request while sitting on the list).
---
 PLAN.md | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

(limited to 'PLAN.md')

diff --git a/PLAN.md b/PLAN.md
index 1393282..80537e1 100644
--- a/PLAN.md
+++ b/PLAN.md
@@ -12,7 +12,12 @@ hudsucker) - same problem, worth studying even though this build is Go.
   (analogous to `rcgen`) for per-domain leaf certs
 - Proxy core: `net/http` + manual `CONNECT` handling, or a MITM proxy
   library if one fits without fighting Go's aggressive header
-  normalization
+  normalization. Upstream requests are round-tripped manually (write
+  the request, read the response off the same connection) rather than
+  through `http.Transport` - Transport's automatic HTTP/2 dispatch keys
+  off a literal `*tls.Conn` type assertion on the dialed connection,
+  which a raw-byte-capturing wrapper around that connection defeats
+  (found by testing: it silently parsed HTTP/2 framing as HTTP/1.1).
 - Storage: SQLite in WAL mode - blob columns for raw request/response
   bytes, FTS5 index for search across bodies
 - UI: Bubble Tea + Lipgloss (TUI), same family as the packet analyzer's
-- 
cgit v1.2.3