Skip to content

High-performance browser automation bridge and multi-instance orchestrator with advanced stealth injection and real-time dashboard.

fix: network export hardening — stream limits, body throttle, eager capture, tmp cleanup (#404)

luigiagent17ac08b57adb
diff --git a/internal/bridge/bridge.go b/internal/bridge/bridge.go
index 72d5a71c..64a077d6 100644
--- a/internal/bridge/bridge.go
+++ b/internal/bridge/bridge.go
@@ -88,6 +88,7 @@ func New(allocCtx, browserCtx context.Context, cfg *config.RuntimeConfig) *Bridg
if cfg != nil && browserCtx != nil {
b.TabManager = NewTabManager(browserCtx, cfg, idMgr, logStore, b.tabSetup)
b.SetDialogManager(b.Dialogs)
+ b.SetNetworkMonitor(b.netMonitor)
if !b.quietStealthObservers() {
b.StartBrowserGuards()
}
@@ -277,6 +278,7 @@ func (b *Bridge) EnsureChrome(cfg *config.RuntimeConfig) error {
}
b.TabManager = NewTabManager(browserCtx, b.Config, b.IdMgr, b.LogStore, b.tabSetup)
b.SetDialogManager(b.Dialogs)
+ b.SetNetworkMonitor(b.netMonitor)
if !b.quietStealthObservers() {
b.StartBrowserGuards()
}
@@ -372,6 +374,7 @@ func (b *Bridge) SetBrowserContexts(allocCtx context.Context, allocCancel contex
}
b.TabManager = NewTabManager(browserCtx, b.Config, b.IdMgr, b.LogStore, b.tabSetup)
b.SetDialogManager(b.Dialogs)
+ b.SetNetworkMonitor(b.netMonitor)
}
}
diff --git a/internal/bridge/observe/format_har.go b/internal/bridge/observe/format_har.go
index b6a69c93..1584261f 100644
--- a/internal/bridge/observe/format_har.go
+++ b/internal/bridge/observe/format_har.go
@@ -33,11 +33,18 @@ func (e *harEncoder) FileExtension() string { return ".har" }
func (e *harEncoder) Start(w io.Writer) error {
e.w = w
e.started = true
- header := fmt.Sprintf(
- `{"log":{"version":"1.2","creator":%s,"entries":[`,
- mustMarshal(e.creator),
- )
- _, err := io.WriteString(e.w, header)
+ creatorJSON, err := json.Marshal(e.creator)
+ if err != nil {
+ return fmt.Errorf("marshal creator: %w", err)
+ }
+ _, err = io.WriteString(e.w, `{"log":{"version":"1.2","creator":`)
+ if err != nil {
+ return err
+ }
+ if _, err = e.w.Write(creatorJSON); err != nil {
+ return err
+ }
+ _, err = io.WriteString(e.w, `,"entries":[`)
return err
}
@@ -68,11 +75,3 @@ func (e *harEncoder) Finish() error {
_, err := io.WriteString(e.w, "]}}\n")
return err
}
-
-func mustMarshal(v any) string {
- b, err := json.Marshal(v)
- if err != nil {
- return "{}"
- }
- return string(b)
-}
diff --git a/internal/bridge/tab_manager.go b/internal/bridge/tab_manager.go
index bad1a837..187bbae3 100644
--- a/internal/bridge/tab_manager.go
+++ b/internal/bridge/tab_manager.go
@@ -31,6 +31,7 @@ type TabManager struct {
onTabSetup TabSetupFunc
dialogMgr *DialogManager
logStore *ConsoleLogStore
+ netMonitor *NetworkMonitor
currentTab string // ID of the most recently used tab
executor *TabExecutor
guardOnce sync.Once
@@ -63,6 +64,11 @@ func (tm *TabManager) SetDialogManager(dm *DialogManager) {
tm.dialogMgr = dm
}
+// SetNetworkMonitor sets the network monitor for eager network capture on new tabs.
+func (tm *TabManager) SetNetworkMonitor(nm *NetworkMonitor) {
+ tm.netMonitor = nm
+}
+
func shouldBlockPopupTarget(info *target.Info) bool {
return info != nil && info.Type == TargetTypePage && info.OpenerID != ""
}
@@ -198,6 +204,11 @@ func (tm *TabManager) TabContext(tabID string) (context.Context, string, error)
if tm.onTabSetup != nil {
tm.onTabSetup(ctx)
}
+ if tm.netMonitor != nil {
+ if err := tm.netMonitor.StartCapture(ctx, tabID); err != nil {
+ slog.Warn("eager network capture failed", "tab", tabID, "err", err)
+ }
+ }
tm.RegisterTabWithCancel(tabID, raw, ctx, cancel)
tm.mu.RLock()
@@ -337,6 +348,16 @@ func (tm *TabManager) CreateTab(url string) (string, context.Context, context.Ca
_ = SetResourceBlocking(ctx, blockPatterns)
}
+ rawCDPID := string(targetID)
+ tabID := tm.idMgr.TabIDFromCDPTarget(rawCDPID)
+
+ // Start network capture before navigation so CDP events are captured.
+ if tm.netMonitor != nil {
+ if err := tm.netMonitor.StartCapture(ctx, tabID); err != nil {
+ slog.Warn("eager network capture failed", "tab", tabID, "err", err)
+ }
+ }
+
if url != "" && url != "about:blank" {
navCtx, navCancel := context.WithTimeout(ctx, 30*time.Second)
if err := chromedp.Run(navCtx, chromedp.Navigate(url)); err != nil {
@@ -348,8 +369,6 @@ func (tm *TabManager) CreateTab(url string) (string, context.Context, context.Ca
navCancel()
}
- rawCDPID := string(targetID)
- tabID := tm.idMgr.TabIDFromCDPTarget(rawCDPID)
now := time.Now()
// Set up dialog event listening for this tab
diff --git a/internal/handlers/handlers.go b/internal/handlers/handlers.go
index 072f3024..b34c1f77 100644
--- a/internal/handlers/handlers.go
+++ b/internal/handlers/handlers.go
@@ -85,6 +85,9 @@ func New(b bridge.BridgeAPI, cfg *config.RuntimeConfig, p bridge.ProfileService,
},
)
+ // Clean up .tmp export files orphaned by a previous crash.
+ go CleanupStaleTmpExports(cfg.StateDir)
+
return h
}
diff --git a/internal/handlers/network_export.go b/internal/handlers/network_export.go
index 315f4bdd..21f57936 100644
--- a/internal/handlers/network_export.go
+++ b/internal/handlers/network_export.go
@@ -21,6 +21,36 @@ import (
// maxExportBodyBytes caps the size of a single response body included in an export.
const maxExportBodyBytes = 10 << 20 // 10 MB
+// maxExportStreamDuration caps how long a streaming export can run before auto-closing.
+const maxExportStreamDuration = 30 * time.Minute
+
+// bodyFetchConcurrency limits parallel CDP GetResponseBody calls to avoid tying up the tab.
+const bodyFetchConcurrency = 4
+
+// staleTmpAge is the minimum age of a .tmp file before it's considered orphaned.
+const staleTmpAge = 5 * time.Minute
+
+// CleanupStaleTmpExports removes orphaned .tmp files from the exports directory.
+// Called at startup to handle files left behind by a crash or hard kill.
+func CleanupStaleTmpExports(stateDir string) {
+ exportDir := filepath.Join(stateDir, "exports")
+ entries, err := os.ReadDir(exportDir)
+ if err != nil {
+ return // directory doesn't exist yet — nothing to clean
+ }
+ cutoff := time.Now().Add(-staleTmpAge)
+ for _, entry := range entries {
+ if entry.IsDir() || !strings.HasSuffix(entry.Name(), ".tmp") {
+ continue
+ }
+ info, err := entry.Info()
+ if err != nil || info.ModTime().After(cutoff) {
+ continue // skip files that might still be in-flight
+ }
+ _ = os.Remove(filepath.Join(exportDir, entry.Name()))
+ }
+}
+
// HandleNetworkExport exports captured network data in a registered format (HAR, NDJSON, etc.).
//
// @Endpoint GET /network/export
@@ -121,26 +151,41 @@ func (h *Handlers) HandleNetworkExport(w http.ResponseWriter, r *http.Request) {
defer fetchCancel()
go httpx.CancelOnClientDone(r.Context(), fetchCancel)
- // Convert entries
- exportEntries := make([]observe.ExportEntry, 0, len(entries))
- for _, entry := range entries {
- var body string
- var b64 bool
- if includeBody && entry.Finished && !entry.Failed {
- body, b64, _ = nm.GetResponseBody(fetchCtx, entry.RequestID)
- // Cap body size (#3)
- if len(body) > maxExportBodyBytes {
- body = ""
- b64 = false
+ // Convert entries with throttled body fetches to avoid tying up the tab context.
+ exportEntries := make([]observe.ExportEntry, len(entries))
+ bodySem := make(chan struct{}, bodyFetchConcurrency)
+ var wg sync.WaitGroup
+
+ for i, entry := range entries {
+ needBody := includeBody && entry.Finished && !entry.Failed
+ if needBody {
+ wg.Add(1)
+ bodySem <- struct{}{}
+ go func(idx int, ent bridge.NetworkEntry) {
+ defer wg.Done()
+ defer func() { <-bodySem }()
+ body, b64, _ := nm.GetResponseBody(fetchCtx, ent.RequestID)
+ if len(body) > maxExportBodyBytes {
+ body = ""
+ b64 = false
+ }
+ e := observe.NetworkEntryToExport(ent, body, b64)
+ if redactHeaders {
+ e.Request.Headers = observe.RedactSensitiveHeaders(e.Request.Headers)
+ e.Response.Headers = observe.RedactSensitiveHeaders(e.Response.Headers)
+ }
+ exportEntries[idx] = e
+ }(i, entry)
+ } else {
+ e := observe.NetworkEntryToExport(entry, "", false)
+ if redactHeaders {
+ e.Request.Headers = observe.RedactSensitiveHeaders(e.Request.Headers)
+ e.Response.Headers = observe.RedactSensitiveHeaders(e.Response.Headers)
}
+ exportEntries[i] = e
}
- e := observe.NetworkEntryToExport(entry, body, b64)
- if redactHeaders {
- e.Request.Headers = observe.RedactSensitiveHeaders(e.Request.Headers)
- e.Response.Headers = observe.RedactSensitiveHeaders(e.Response.Headers)
- }
- exportEntries = append(exportEntries, e)
}
+ wg.Wait()
enc := factory("PinchTab", h.version())
@@ -350,6 +395,9 @@ func (h *Handlers) HandleNetworkExportStream(w http.ResponseWriter, r *http.Requ
return
}
+ // Semaphore to throttle concurrent body fetches in streaming mode.
+ streamBodySem := make(chan struct{}, bodyFetchConcurrency)
+
// Subscribe for live entries
subID, ch := buf.Subscribe()
defer buf.Unsubscribe(subID)
@@ -369,7 +417,11 @@ func (h *Handlers) HandleNetworkExportStream(w http.ResponseWriter, r *http.Requ
w.Header().Set("Connection", "keep-alive")
w.Header().Set("X-Accel-Buffering", "no")
- // Clear write deadline for long-lived SSE (#7)
+ // Set a hard deadline so forgotten streams don't leak resources.
+ streamDeadline := time.NewTimer(maxExportStreamDuration)
+ defer streamDeadline.Stop()
+
+ // Clear per-write deadline for long-lived SSE (#7), the stream timer above caps total duration.
_ = http.NewResponseController(w).SetWriteDeadline(time.Time{})
count := 0
@@ -393,6 +445,17 @@ func (h *Handlers) HandleNetworkExportStream(w http.ResponseWriter, r *http.Requ
})
}
+ // sendDone emits the final SSE event with the correct path (empty when no file was written).
+ sendDone := func() {
+ result := map[string]any{"entries": count}
+ if count > 0 {
+ result["path"] = absPath
+ }
+ data, _ := json.Marshal(result)
+ _, _ = fmt.Fprintf(w, "event: done\ndata: %s\n\n", data)
+ flusher.Flush()
+ }
+
for {
select {
case <-r.Context().Done():
@@ -400,12 +463,17 @@ func (h *Handlers) HandleNetworkExportStream(w http.ResponseWriter, r *http.Requ
// Don't write to ResponseWriter after client disconnect (#6)
return
+ case <-streamDeadline.C:
+ finalize()
+ data, _ := json.Marshal(map[string]any{"entries": count, "reason": "max_duration_reached"})
+ _, _ = fmt.Fprintf(w, "event: timeout\ndata: %s\n\n", data)
+ sendDone()
+ return
+
case entry, ok := <-ch:
if !ok {
finalize()
- data, _ := json.Marshal(map[string]any{"entries": count, "path": absPath})
- _, _ = fmt.Fprintf(w, "event: done\ndata: %s\n\n", data)
- flusher.Flush()
+ sendDone()
return
}
@@ -445,7 +513,10 @@ func (h *Handlers) HandleNetworkExportStream(w http.ResponseWriter, r *http.Requ
var body string
var b64 bool
if includeBody && entry.Finished && !entry.Failed {
+ // Throttle body fetches to avoid saturating the CDP connection.
+ streamBodySem <- struct{}{}
body, b64, _ = nm.GetResponseBody(tabCtx, entry.RequestID)
+ <-streamBodySem
if len(body) > maxExportBodyBytes {
body = ""
b64 = false
diff --git a/internal/handlers/network_export_test.go b/internal/handlers/network_export_test.go
new file mode 100644
index 00000000..13c3fa4a
--- /dev/null
+++ b/internal/handlers/network_export_test.go
@@ -0,0 +1,55 @@
+package handlers
+
+import (
+ "os"
+ "path/filepath"
+ "testing"
+ "time"
+)
+
+func TestCleanupStaleTmpExports(t *testing.T) {
+ stateDir := t.TempDir()
+ exportDir := filepath.Join(stateDir, "exports")
+ if err := os.MkdirAll(exportDir, 0750); err != nil {
+ t.Fatal(err)
+ }
+
+ // Create a stale .tmp file (backdate mtime well past the 5-min threshold).
+ stalePath := filepath.Join(exportDir, "network-old.har.tmp")
+ if err := os.WriteFile(stalePath, []byte("stale"), 0600); err != nil {
+ t.Fatal(err)
+ }
+ staleTime := time.Now().Add(-10 * time.Minute)
+ if err := os.Chtimes(stalePath, staleTime, staleTime); err != nil {
+ t.Fatal(err)
+ }
+
+ // Create a fresh .tmp file that should be kept (could be in-flight).
+ freshPath := filepath.Join(exportDir, "network-new.ndjson.tmp")
+ if err := os.WriteFile(freshPath, []byte("fresh"), 0600); err != nil {
+ t.Fatal(err)
+ }
+
+ // Create a regular completed file that should never be touched.
+ completedPath := filepath.Join(exportDir, "session.har")
+ if err := os.WriteFile(completedPath, []byte("done"), 0600); err != nil {
+ t.Fatal(err)
+ }
+
+ CleanupStaleTmpExports(stateDir)
+
+ if _, err := os.Stat(stalePath); !os.IsNotExist(err) {
+ t.Error("stale .tmp file should have been removed")
+ }
+ if _, err := os.Stat(freshPath); err != nil {
+ t.Error("fresh .tmp file should have been kept")
+ }
+ if _, err := os.Stat(completedPath); err != nil {
+ t.Error("completed .har file should have been kept")
+ }
+}
+
+func TestCleanupStaleTmpExports_NoDir(t *testing.T) {
+ // Should not panic when exports/ doesn't exist.
+ CleanupStaleTmpExports(t.TempDir())
+}
diff --git a/tests/e2e/scenarios-api/network-basic.sh b/tests/e2e/scenarios-api/network-basic.sh
new file mode 100755
index 00000000..3a3a4ce9
--- /dev/null
+++ b/tests/e2e/scenarios-api/network-basic.sh
@@ -0,0 +1,96 @@
+#!/bin/bash
+# network-basic.sh — Basic network capture API tests.
+# Covers: /network, /network/{requestId}, /network/clear
+
+GROUP_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${GROUP_DIR}/../helpers/api.sh"
+
+# ─────────────────────────────────────────────────────────────────
+start_test "GET /network: returns entries after navigation"
+
+pt_post /navigate "{\"url\":\"${FIXTURES_URL}/buttons.html\"}"
+TAB_ID=$(get_tab_id)
+sleep 1
+
+pt_get "/network?tabId=${TAB_ID}"
+assert_ok "get network entries"
+assert_json_exists "$RESULT" '.entries' "has entries array"
+assert_json_exists "$RESULT" '.tabId' "has tabId"
+
+ENTRIES_COUNT=$(echo "$RESULT" | jq '.entries | length')
+if [ "$ENTRIES_COUNT" -gt 0 ]; then
+ echo -e " ${GREEN}✓${NC} captured $ENTRIES_COUNT network entries"
+ ((ASSERTIONS_PASSED++)) || true
+else
+ echo -e " ${YELLOW}~${NC} no entries yet (timing-dependent)"
+ ((ASSERTIONS_PASSED++)) || true
+fi
+
+end_test
+
+# ─────────────────────────────────────────────────────────────────
+start_test "GET /network: filter by method"
+
+pt_get "/network?tabId=${TAB_ID}&method=GET"
+assert_ok "filter by GET"
+
+end_test
+
+# ─────────────────────────────────────────────────────────────────
+start_test "GET /network: limit parameter"
+
+pt_get "/network?tabId=${TAB_ID}&limit=2"
+assert_ok "get with limit"
+
+ENTRIES_COUNT=$(echo "$RESULT" | jq '.entries | length')
+if [ "$ENTRIES_COUNT" -le 2 ]; then
+ echo -e " ${GREEN}✓${NC} limit respected: $ENTRIES_COUNT <= 2"
+ ((ASSERTIONS_PASSED++)) || true
+else
+ echo -e " ${RED}✗${NC} limit exceeded: $ENTRIES_COUNT > 2"
+ ((ASSERTIONS_FAILED++)) || true
+fi
+
+end_test
+
+# ─────────────────────────────────────────────────────────────────
+start_test "GET /network: non-existent tab → error"
+
+pt_get "/network?tabId=nonexistent_xyz_999"
+assert_not_ok "rejects bad tab"
+
+end_test
+
+# ─────────────────────────────────────────────────────────────────
+start_test "POST /network/clear: clears entries"
+
+pt_post /network/clear "{\"tabId\":\"${TAB_ID}\"}"
+assert_ok "clear network"
+
+pt_get "/network?tabId=${TAB_ID}"
+assert_ok "get after clear"
+
+ENTRIES_COUNT=$(echo "$RESULT" | jq '.entries | length')
+if [ "$ENTRIES_COUNT" -eq 0 ]; then
+ echo -e " ${GREEN}✓${NC} entries cleared"
+ ((ASSERTIONS_PASSED++)) || true
+else
+ echo -e " ${YELLOW}~${NC} $ENTRIES_COUNT entries remain after clear"
+ ((ASSERTIONS_PASSED++)) || true
+fi
+
+end_test
+
+# ─────────────────────────────────────────────────────────────────
+start_test "GET /network/export: basic HAR export works"
+
+# Generate fresh traffic
+pt_post /navigate "{\"url\":\"${FIXTURES_URL}/index.html\"}"
+sleep 1
+
+pt_get "/network/export?tabId=${TAB_ID}"
+assert_ok "basic HAR export"
+assert_result_jq '.log.version' "1.2" "HAR version 1.2"
+assert_json_exists "$RESULT" '.log.entries' "has entries"
+
+end_test
diff --git a/tests/e2e/scenarios-api/network-full.sh b/tests/e2e/scenarios-api/network-full.sh
new file mode 100755
index 00000000..8cd4886d
--- /dev/null
+++ b/tests/e2e/scenarios-api/network-full.sh
@@ -0,0 +1,418 @@
+#!/bin/bash
+# network-full.sh — Network capture & export API tests.
+# Covers: /network/export, /network/export/stream, format registry,
+# header redaction, body inclusion, file output, and tab-scoped variants.
+
+GROUP_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${GROUP_DIR}/../helpers/api.sh"
+
+# ─────────────────────────────────────────────────────────────────
+# Setup: navigate to a page that generates network traffic
+# ─────────────────────────────────────────────────────────────────
+
+pt_post /navigate "{\"url\":\"${FIXTURES_URL}/buttons.html\"}"
+TAB_ID=$(get_tab_id)
+sleep 1
+
+# ─────────────────────────────────────────────────────────────────
+start_test "GET /network/export: default HAR format"
+
+pt_get "/network/export?tabId=${TAB_ID}"
+assert_ok "export HAR"
+
+# Validate HAR structure
+assert_result_jq '.log.version' "1.2" "HAR version is 1.2"
+assert_json_exists "$RESULT" '.log.creator.name' "has creator name"
+assert_json_exists "$RESULT" '.log.entries' "has entries array"
+
+ENTRY_COUNT=$(echo "$RESULT" | jq '.log.entries | length')
+if [ "$ENTRY_COUNT" -gt 0 ]; then
+ echo -e " ${GREEN}✓${NC} HAR contains $ENTRY_COUNT entries"
+ ((ASSERTIONS_PASSED++)) || true
+else
+ echo -e " ${RED}✗${NC} HAR has no entries (expected traffic from navigation)"
+ ((ASSERTIONS_FAILED++)) || true
+fi
+
+end_test
+
+# ─────────────────────────────────────────────────────────────────
+start_test "GET /network/export: explicit format=har"
+
+pt_get "/network/export?tabId=${TAB_ID}&format=har"
+assert_ok "export format=har"
+assert_result_jq '.log.version' "1.2" "HAR version"
+
+end_test
+
+# ─────────────────────────────────────────────────────────────────
+start_test "GET /network/export: NDJSON format"
+
+pinchtab GET "/network/export?tabId=${TAB_ID}&format=ndjson"
+
+if [ "$HTTP_STATUS" = "200" ]; then
+ echo -e " ${GREEN}✓${NC} NDJSON export → 200"
+ ((ASSERTIONS_PASSED++)) || true
+
+ # Each line should be valid JSON
+ LINE_COUNT=$(echo "$RESULT" | grep -c '^{' || true)
+ if [ "$LINE_COUNT" -gt 0 ]; then
+ FIRST_LINE=$(echo "$RESULT" | head -1)
+ echo "$FIRST_LINE" | jq . >/dev/null 2>&1
+ if [ $? -eq 0 ]; then
+ echo -e " ${GREEN}✓${NC} NDJSON lines are valid JSON ($LINE_COUNT lines)"
+ ((ASSERTIONS_PASSED++)) || true
+ else
+ echo -e " ${RED}✗${NC} first NDJSON line is not valid JSON"
+ ((ASSERTIONS_FAILED++)) || true
+ fi
+ else
+ echo -e " ${YELLOW}~${NC} no NDJSON lines (empty export)"
+ ((ASSERTIONS_PASSED++)) || true
+ fi
+else
+ echo -e " ${RED}✗${NC} NDJSON export failed ($HTTP_STATUS)"
+ ((ASSERTIONS_FAILED++)) || true
+fi
+
+end_test
+
+# ─────────────────────────────────────────────────────────────────
+start_test "GET /network/export: unknown format returns 400 with available list"
+
+pt_get "/network/export?tabId=${TAB_ID}&format=xml"
+assert_http_status "400" "unknown format → 400"
+assert_json_contains "$RESULT" '.code' "unknown_format" "error code"
+assert_json_exists "$RESULT" '.available' "lists available formats"
+
+AVAILABLE=$(echo "$RESULT" | jq -r '.available | join(",")')
+if echo "$AVAILABLE" | grep -q "har" && echo "$AVAILABLE" | grep -q "ndjson"; then
+ echo -e " ${GREEN}✓${NC} available includes har and ndjson: $AVAILABLE"
+ ((ASSERTIONS_PASSED++)) || true
+else
+ echo -e " ${RED}✗${NC} unexpected available formats: $AVAILABLE"
+ ((ASSERTIONS_FAILED++)) || true
+fi
+
+end_test
+
+# ─────────────────────────────────────────────────────────────────
+start_test "GET /network/export: sensitive headers redacted by default"
+
+pt_get "/network/export?tabId=${TAB_ID}&format=har"
+assert_ok "export for redaction check"
+
+# Check that no entry has un-redacted Cookie or Authorization headers
+LEAKED=$(echo "$RESULT" | jq '[
+ .log.entries[]
+ | (.request.headers + .response.headers)[]
+ | select((.name | ascii_downcase) == "cookie" or
+ (.name | ascii_downcase) == "authorization" or
+ (.name | ascii_downcase) == "set-cookie")
+ | select(.value != "[REDACTED]")
+] | length')
+
+if [ "$LEAKED" = "0" ] || [ "$LEAKED" = "null" ]; then
+ echo -e " ${GREEN}✓${NC} no leaked sensitive headers"
+ ((ASSERTIONS_PASSED++)) || true
+else
+ echo -e " ${RED}✗${NC} found $LEAKED un-redacted sensitive header values"
+ ((ASSERTIONS_FAILED++)) || true
+fi
+
+end_test
+
+# ─────────────────────────────────────────────────────────────────
+start_test "GET /network/export: redact=false exposes raw headers"
+
+pt_get "/network/export?tabId=${TAB_ID}&format=har&redact=false"
+assert_ok "export with redact=false"
+
+# Just verify it returns valid HAR — we can't guarantee the fixture sets cookies,
+# but the flag should be accepted without error.
+assert_result_jq '.log.version' "1.2" "HAR still valid with redact=false"
+
+end_test
+
+# ─────────────────────────────────────────────────────────────────
+start_test "GET /network/export: body=true includes response content"
+
+pt_get "/network/export?tabId=${TAB_ID}&format=har&body=true"
+assert_ok "export with bodies"
+
+# At least one entry should have non-empty content.text for an HTML page
+HAS_BODY=$(echo "$RESULT" | jq '[.log.entries[] | select(.response.content.text != null and .response.content.text != "")] | length')
+if [ "$HAS_BODY" -gt 0 ]; then
+ echo -e " ${GREEN}✓${NC} $HAS_BODY entries include response body"
+ ((ASSERTIONS_PASSED++)) || true
+else
+ echo -e " ${YELLOW}~${NC} no entries have body content (may depend on timing)"
+ ((ASSERTIONS_PASSED++)) || true
+fi
+
+end_test
+
+# ─────────────────────────────────────────────────────────────────
+start_test "GET /network/export: filter by method"
+
+pt_get "/network/export?tabId=${TAB_ID}&format=har&method=GET"
+assert_ok "export filter method=GET"
+
+NON_GET=$(echo "$RESULT" | jq '[.log.entries[] | select(.request.method != "GET")] | length')
+if [ "$NON_GET" = "0" ] || [ "$NON_GET" = "null" ]; then
+ echo -e " ${GREEN}✓${NC} all exported entries are GET"
+ ((ASSERTIONS_PASSED++)) || true
+else
+ echo -e " ${RED}✗${NC} found $NON_GET non-GET entries"
+ ((ASSERTIONS_FAILED++)) || true
+fi
+
+end_test
+
+# ─────────────────────────────────────────────────────────────────
+start_test "GET /network/export: limit parameter"
+
+pt_get "/network/export?tabId=${TAB_ID}&format=har&limit=2"
+assert_ok "export with limit=2"
+
+ENTRY_COUNT=$(echo "$RESULT" | jq '.log.entries | length')
+if [ "$ENTRY_COUNT" -le 2 ]; then
+ echo -e " ${GREEN}✓${NC} limit respected: $ENTRY_COUNT entries (<= 2)"
+ ((ASSERTIONS_PASSED++)) || true
+else
+ echo -e " ${RED}✗${NC} limit exceeded: $ENTRY_COUNT entries (expected <= 2)"
+ ((ASSERTIONS_FAILED++)) || true
+fi
+
+end_test
+
+# ─────────────────────────────────────────────────────────────────
+start_test "GET /network/export: output=file saves to disk"
+
+pt_get "/network/export?tabId=${TAB_ID}&format=har&output=file&path=e2e-test.har"
+assert_ok "export to file"
+assert_json_exists "$RESULT" '.path' "response has file path"
+assert_json_exists "$RESULT" '.entries' "response has entry count"
+assert_json_contains "$RESULT" '.format' "har" "format in response"
+
+FILE_ENTRIES=$(echo "$RESULT" | jq '.entries')
+if [ "$FILE_ENTRIES" -gt 0 ] 2>/dev/null; then
+ echo -e " ${GREEN}✓${NC} file has $FILE_ENTRIES entries"
+ ((ASSERTIONS_PASSED++)) || true
+else
+ echo -e " ${YELLOW}~${NC} file written with $FILE_ENTRIES entries"
+ ((ASSERTIONS_PASSED++)) || true
+fi
+
+end_test
+
+# ─────────────────────────────────────────────────────────────────
+start_test "GET /network/export: output=file auto-generates name"
+
+pt_get "/network/export?tabId=${TAB_ID}&format=har&output=file"
+assert_ok "export to auto-named file"
+assert_json_exists "$RESULT" '.path' "has auto-generated path"
+
+AUTO_PATH=$(echo "$RESULT" | jq -r '.path')
+if echo "$AUTO_PATH" | grep -q "network-.*\.har$"; then
+ echo -e " ${GREEN}✓${NC} auto-generated filename: $(basename "$AUTO_PATH")"
+ ((ASSERTIONS_PASSED++)) || true
+else
+ echo -e " ${RED}✗${NC} unexpected auto filename: $AUTO_PATH"
+ ((ASSERTIONS_FAILED++)) || true
+fi
+
+end_test
+
+# ─────────────────────────────────────────────────────────────────
+start_test "GET /network/export: output=file with NDJSON"
+
+pt_get "/network/export?tabId=${TAB_ID}&format=ndjson&output=file&path=e2e-test.ndjson"
+assert_ok "NDJSON file export"
+assert_json_contains "$RESULT" '.format' "ndjson" "format in response"
+
+end_test
+
+# ─────────────────────────────────────────────────────────────────
+# Tab-scoped export endpoints
+# ─────────────────────────────────────────────────────────────────
+
+start_test "GET /tabs/{id}/network/export: tab-scoped HAR export"
+
+pt_get "/tabs/${TAB_ID}/network/export"
+assert_ok "tab-scoped export"
+assert_result_jq '.log.version' "1.2" "HAR version"
+
+end_test
+
+# ─────────────────────────────────────────────────────────────────
+start_test "GET /tabs/{id}/network/export: bad tab → error"
+
+pt_get "/tabs/nonexistent_xyz_999/network/export"
+assert_not_ok "rejects bad tab"
+
+end_test
+
+# ─────────────────────────────────────────────────────────────────
+# Streaming export
+# ─────────────────────────────────────────────────────────────────
+
+start_test "GET /network/export/stream: requires path parameter"
+
+pt_get "/network/export/stream?tabId=${TAB_ID}"
+assert_http_status "400" "missing path → 400"
+
+end_test
+
+# ─────────────────────────────────────────────────────────────────
+start_test "GET /network/export/stream: SSE events on navigation"
+
+# Start a streaming export in background, navigate, then check output.
+# We use a short timeout curl to capture initial SSE events.
+STREAM_OUTPUT=$(e2e_curl -s -N \
+ --max-time 5 \
+ -H "Content-Type: application/json" \
+ "${E2E_SERVER}/network/export/stream?tabId=${TAB_ID}&format=har&path=e2e-stream.har" \
+ 2>/dev/null || true)
+
+# Trigger traffic while the stream might still be running
+pt_post /navigate "{\"url\":\"${FIXTURES_URL}/form.html\"}"
+sleep 2
+
+# The curl with --max-time will have timed out by now. Check output.
+if echo "$STREAM_OUTPUT" | grep -q "event:"; then
+ echo -e " ${GREEN}✓${NC} received SSE events from stream"
+ ((ASSERTIONS_PASSED++)) || true
+elif echo "$STREAM_OUTPUT" | grep -q "text/event-stream"; then
+ echo -e " ${GREEN}✓${NC} stream responded with SSE content-type"
+ ((ASSERTIONS_PASSED++)) || true
+else
+ # Even without events the endpoint should have started successfully (200)
+ echo -e " ${YELLOW}~${NC} no SSE events captured (timing-dependent)"
+ ((ASSERTIONS_PASSED++)) || true
+fi
+
+end_test
+
+# ─────────────────────────────────────────────────────────────────
+start_test "GET /tabs/{id}/network/export/stream: requires path"
+
+pt_get "/tabs/${TAB_ID}/network/export/stream"
+assert_http_status "400" "tab-scoped stream missing path → 400"
+
+end_test
+
+# ─────────────────────────────────────────────────────────────────
+# HAR entry structure validation
+# ─────────────────────────────────────────────────────────────────
+
+start_test "HAR entries have correct structure"
+
+pt_get "/network/export?tabId=${TAB_ID}&format=har"
+assert_ok "export for structure check"
+
+ENTRY_COUNT=$(echo "$RESULT" | jq '.log.entries | length')
+if [ "$ENTRY_COUNT" -gt 0 ]; then
+ # Check first entry has required HAR fields
+ FIRST=$(echo "$RESULT" | jq '.log.entries[0]')
+
+ for field in startedDateTime time request response timings; do
+ VAL=$(echo "$FIRST" | jq ".$field")
+ if [ "$VAL" != "null" ] && [ -n "$VAL" ]; then
+ echo -e " ${GREEN}✓${NC} entry has .$field"
+ ((ASSERTIONS_PASSED++)) || true
+ else
+ echo -e " ${RED}✗${NC} entry missing .$field"
+ ((ASSERTIONS_FAILED++)) || true
+ fi
+ done
+
+ # Check request sub-fields
+ for field in method url httpVersion headers queryString; do
+ VAL=$(echo "$FIRST" | jq ".request.$field")
+ if [ "$VAL" != "null" ] && [ -n "$VAL" ]; then
+ echo -e " ${GREEN}✓${NC} request has .$field"
+ ((ASSERTIONS_PASSED++)) || true
+ else
+ echo -e " ${RED}✗${NC} request missing .$field"
+ ((ASSERTIONS_FAILED++)) || true
+ fi
+ done
+
+ # Check response sub-fields
+ for field in status statusText httpVersion headers content; do
+ VAL=$(echo "$FIRST" | jq ".response.$field")
+ if [ "$VAL" != "null" ] && [ -n "$VAL" ]; then
+ echo -e " ${GREEN}✓${NC} response has .$field"
+ ((ASSERTIONS_PASSED++)) || true
+ else
+ echo -e " ${RED}✗${NC} response missing .$field"
+ ((ASSERTIONS_FAILED++)) || true
+ fi
+ done
+
+ # Check timings
+ for field in send wait receive; do
+ VAL=$(echo "$FIRST" | jq ".timings.$field")
+ if [ "$VAL" != "null" ] && [ -n "$VAL" ]; then
+ echo -e " ${GREEN}✓${NC} timings has .$field"
+ ((ASSERTIONS_PASSED++)) || true
+ else
+ echo -e " ${RED}✗${NC} timings missing .$field"
+ ((ASSERTIONS_FAILED++)) || true
+ fi
+ done
+else
+ echo -e " ${YELLOW}~${NC} no entries to validate structure"
+ ((ASSERTIONS_PASSED++)) || true
+fi
+
+end_test
+
+# ─────────────────────────────────────────────────────────────────
+# Network basics (moved from browser-full for grouping)
+# ─────────────────────────────────────────────────────────────────
+
+start_test "GET /network: list entries with filters"
+
+pt_post /navigate "{\"url\":\"${FIXTURES_URL}/index.html\"}"
+NEW_TAB_ID=$(get_tab_id)
+sleep 1
+
+pt_get "/network?tabId=${NEW_TAB_ID}"
+assert_ok "get network entries"
+assert_json_exists "$RESULT" '.entries' "has entries"
+
+pt_get "/network?tabId=${NEW_TAB_ID}&method=GET&limit=3"
+assert_ok "filter + limit"
+
+ENTRIES_COUNT=$(echo "$RESULT" | jq '.entries | length')
+if [ "$ENTRIES_COUNT" -le 3 ]; then
+ echo -e " ${GREEN}✓${NC} limit respected: $ENTRIES_COUNT <= 3"
+ ((ASSERTIONS_PASSED++)) || true
+else
+ echo -e " ${RED}✗${NC} limit exceeded: $ENTRIES_COUNT > 3"
+ ((ASSERTIONS_FAILED++)) || true
+fi
+
+end_test
+
+# ─────────────────────────────────────────────────────────────────
+start_test "POST /network/clear: clears captured data"
+
+pt_post /network/clear "{\"tabId\":\"${NEW_TAB_ID}\"}"
+assert_ok "clear network"
+
+pt_get "/network?tabId=${NEW_TAB_ID}"
+assert_ok "get after clear"
+
+ENTRIES_COUNT=$(echo "$RESULT" | jq '.entries | length')
+if [ "$ENTRIES_COUNT" -eq 0 ]; then
+ echo -e " ${GREEN}✓${NC} entries cleared"
+ ((ASSERTIONS_PASSED++)) || true
+else
+ echo -e " ${YELLOW}~${NC} still has $ENTRIES_COUNT entries after clear"
+ ((ASSERTIONS_PASSED++)) || true
+fi
+
+end_test