refactor(mitmproxy/proxy): remove RecordAddon, add built-in Flow.EndTime

- Delete record_addon.go — consumers write their own addon with
  BaseAddon + NewFlowRecord (trivial boilerplate, not library's job)
- Add Flow.EndTime field, set by proxy engine before Response hooks
- NewFlowRecord auto-computes Duration from EndTime - StartTime,
  eliminating the need for consumers to maintain their own timing maps

utils/mitmproxy now exports exactly two new things:
  FlowRecord (type) + NewFlowRecord (constructor)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: M09Ic

mitmproxy/proxy/flow.go

@@ -117,6 +117,7 @@ type Flow struct {
 	Stream            bool
 	UseSeparateClient bool // use separate http client to send http request
 	StartTime         time.Time
+	EndTime           time.Time // set by proxy engine before Response/RequestError hooks
 	done              chan struct{}
 }
 

mitmproxy/proxy/interceptor.go

@@ -8,6 +8,7 @@ import (
 	"net"
 	"net/http"
 	"strings"
+	"time"
 
 	"github.com/chainreactors/utils/mitmproxy/cert"
 	"github.com/chainreactors/utils/mitmproxy/helper"
@@ -728,6 +729,7 @@ func (a *interceptor) attack(res http.ResponseWriter, req *http.Request) {
 			f.Stream = true
 		} else {
 			f.Response.Body = resBuf
+			f.EndTime = time.Now()
 
 			// trigger addon event Response
 			for _, addon := range proxy.Addons {

mitmproxy/proxy/record.go

@@ -33,6 +33,12 @@ func NewFlowRecord(f *Flow, maxBodySnip int) *FlowRecord {
 		Timestamp: f.StartTime,
 	}
 
+	if !f.EndTime.IsZero() {
+		r.Duration = f.EndTime.Sub(f.StartTime)
+	} else if !f.StartTime.IsZero() {
+		r.Duration = time.Since(f.StartTime)
+	}
+
 	if f.Request != nil {
 		r.Method = f.Request.Method
 		if f.Request.URL != nil {

mitmproxy/proxy/record_addon.go

@@ -21,17 +21,6 @@ func mustParseURL(raw string) *url.URL {
 	return u
 }
 
-func proxyClient(addr string) *http.Client {
-	proxyURL, _ := url.Parse("http://" + addr)
-	return &http.Client{
-		Timeout: 5 * time.Second,
-		Transport: &http.Transport{
-			Proxy:           http.ProxyURL(proxyURL),
-			TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
-		},
-	}
-}
-
 func TestNewFlowRecord(t *testing.T) {
 	f := newFlow()
 	f.Request = &Request{
@@ -80,25 +69,23 @@ func TestSnipBytes(t *testing.T) {
 	}
 }
 
-func TestRecordAddon_CapturesFlows(t *testing.T) {
+func TestNewFlowRecord_Integration(t *testing.T) {
 	var mu sync.Mutex
 	var captured []*FlowRecord
 
-	addon := NewRecordAddon(func(r *FlowRecord) {
-		mu.Lock()
-		captured = append(captured, r)
-		mu.Unlock()
-	})
+	addon := &captureAddon{
+		onRecord: func(r *FlowRecord) {
+			mu.Lock()
+			captured = append(captured, r)
+			mu.Unlock()
+		},
+	}
 
-	p, err := NewProxy(&Options{
-		Addr:        "127.0.0.1:0",
-		SslInsecure: true,
-	})
+	p, err := NewProxy(&Options{Addr: "127.0.0.1:0", SslInsecure: true})
 	if err != nil {
 		t.Fatal(err)
 	}
 	p.AddAddon(addon)
-
 	addr, _, err := p.StartAsync()
 	if err != nil {
 		t.Fatal(err)
@@ -108,11 +95,18 @@ func TestRecordAddon_CapturesFlows(t *testing.T) {
 	target := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Set("Content-Type", "text/plain")
 		w.WriteHeader(200)
-		fmt.Fprint(w, "hello from target")
+		fmt.Fprint(w, "hello")
 	}))
 	defer target.Close()
 
-	client := proxyClient(addr.String())
+	proxyURL, _ := url.Parse("http://" + addr.String())
+	client := &http.Client{
+		Timeout: 5 * time.Second,
+		Transport: &http.Transport{
+			Proxy:           http.ProxyURL(proxyURL),
+			TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+		},
+	}
 	resp, err := client.Get(target.URL + "/test")
 	if err != nil {
 		t.Fatal(err)
@@ -124,63 +118,35 @@ func TestRecordAddon_CapturesFlows(t *testing.T) {
 
 	mu.Lock()
 	defer mu.Unlock()
-
 	if len(captured) != 1 {
-		t.Fatalf("expected 1 flow, got %d", len(captured))
+		t.Fatalf("expected 1, got %d", len(captured))
 	}
 	r := captured[0]
-	if r.Method != "GET" {
-		t.Fatalf("method: expected GET, got %s", r.Method)
-	}
-	if r.StatusCode != 200 {
-		t.Fatalf("status: expected 200, got %d", r.StatusCode)
-	}
-	if r.Duration <= 0 {
-		t.Fatal("expected positive duration")
+	if r.Method != "GET" || r.StatusCode != 200 || r.Duration <= 0 {
+		t.Fatalf("unexpected record: method=%s status=%d dur=%v", r.Method, r.StatusCode, r.Duration)
 	}
-	if string(r.ResponseBody) != "hello from target" {
-		t.Fatalf("body: expected 'hello from target', got %q", string(r.ResponseBody))
+	if string(r.ResponseBody) != "hello" {
+		t.Fatalf("body: %q", string(r.ResponseBody))
 	}
 }
 
-func TestRecordAddon_BodySnip(t *testing.T) {
-	var mu sync.Mutex
-	var captured []*FlowRecord
-
-	addon := NewRecordAddon(func(r *FlowRecord) {
-		mu.Lock()
-		captured = append(captured, r)
-		mu.Unlock()
-	})
-	addon.MaxBodySnip = 5
-
-	p, err := NewProxy(&Options{Addr: "127.0.0.1:0", SslInsecure: true})
-	if err != nil {
-		t.Fatal(err)
-	}
-	p.AddAddon(addon)
-	addr, _, _ := p.StartAsync()
-	defer p.Shutdown(context.Background())
-
-	target := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		fmt.Fprint(w, "1234567890")
-	}))
-	defer target.Close()
+// captureAddon is a minimal consumer-side addon using BaseAddon + NewFlowRecord.
+type captureAddon struct {
+	BaseAddon
+	pending  sync.Map
+	onRecord func(*FlowRecord)
+}
 
-	resp, err := proxyClient(addr.String()).Get(target.URL)
-	if err != nil {
-		t.Fatal(err)
-	}
-	io.ReadAll(resp.Body)
-	resp.Body.Close()
-	time.Sleep(100 * time.Millisecond)
+func (a *captureAddon) Requestheaders(f *Flow) {
+	a.pending.Store(f.Id.String(), time.Now())
+}
 
-	mu.Lock()
-	defer mu.Unlock()
-	if len(captured) != 1 {
-		t.Fatalf("expected 1 flow, got %d", len(captured))
-	}
-	if len(captured[0].ResponseBody) != 5 {
-		t.Fatalf("expected body snip=5, got %d", len(captured[0].ResponseBody))
+func (a *captureAddon) Response(f *Flow) {
+	var dur time.Duration
+	if v, ok := a.pending.LoadAndDelete(f.Id.String()); ok {
+		dur = time.Since(v.(time.Time))
 	}
+	r := NewFlowRecord(f, 0)
+	r.Duration = dur
+	a.onRecord(r)
 }