Skip to content

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

feat: detect broken assets via GET /network?broken=true

Luigi Agosti4757bc23a270
diff --git a/internal/bridge/observe/network.go b/internal/bridge/observe/network.go
index 0cf38a5d..bba4f885 100644
--- a/internal/bridge/observe/network.go
+++ b/internal/bridge/observe/network.go
@@ -5,6 +5,7 @@ import (
"encoding/json"
"fmt"
"log/slog"
+ "strings"
"sync"
"time"
@@ -469,3 +470,37 @@ func normalizeNetworkHeaders(headers map[string]string) map[string]string {
}
return normalized
}
+
+// BrokenAsset is a subresource that failed to load: an HTTP error response
+// (status >= 400) or a request that failed outright (network error, abort).
+type BrokenAsset struct {
+ URL string `json:"url"`
+ ResourceType string `json:"resourceType"`
+ StatusCode int `json:"statusCode"`
+ Error string `json:"error,omitempty"`
+}
+
+// IsBrokenAsset reports whether entry represents a failed load: a response
+// with status >= 400, or a failed request. In-flight requests are not broken.
+func IsBrokenAsset(entry NetworkEntry) bool {
+ return entry.Status >= 400 || entry.Failed
+}
+
+// BrokenAssets classifies the broken loads in entries. Resource types are
+// the CDP categories lowercased (image, script, stylesheet, font, xhr,
+// fetch, document, ...).
+func BrokenAssets(entries []NetworkEntry) []BrokenAsset {
+ broken := []BrokenAsset{}
+ for _, entry := range entries {
+ if !IsBrokenAsset(entry) {
+ continue
+ }
+ broken = append(broken, BrokenAsset{
+ URL: entry.URL,
+ ResourceType: strings.ToLower(entry.ResourceType),
+ StatusCode: entry.Status,
+ Error: entry.Error,
+ })
+ }
+ return broken
+}
diff --git a/internal/bridge/observe/network_broken_test.go b/internal/bridge/observe/network_broken_test.go
new file mode 100644
index 00000000..a032b093
--- /dev/null
+++ b/internal/bridge/observe/network_broken_test.go
@@ -0,0 +1,61 @@
+package observe
+
+import (
+ "reflect"
+ "testing"
+)
+
+func TestIsBrokenAssetMatrix(t *testing.T) {
+ cases := []struct {
+ name string
+ entry NetworkEntry
+ want bool
+ }{
+ {"ok document", NetworkEntry{Status: 200, ResourceType: "Document", Finished: true}, false},
+ {"ok image", NetworkEntry{Status: 200, ResourceType: "Image", Finished: true}, false},
+ {"redirect", NetworkEntry{Status: 302, ResourceType: "Document", Finished: true}, false},
+ {"404 image", NetworkEntry{Status: 404, ResourceType: "Image", Finished: true}, true},
+ {"404 script", NetworkEntry{Status: 404, ResourceType: "Script", Finished: true}, true},
+ {"404 stylesheet", NetworkEntry{Status: 404, ResourceType: "Stylesheet", Finished: true}, true},
+ {"404 fetch", NetworkEntry{Status: 404, ResourceType: "Fetch", Finished: true}, true},
+ {"500 xhr", NetworkEntry{Status: 500, ResourceType: "XHR", Finished: true}, true},
+ {"403 font", NetworkEntry{Status: 403, ResourceType: "Font", Finished: true}, true},
+ {"network error", NetworkEntry{Failed: true, Error: "net::ERR_CONNECTION_REFUSED", ResourceType: "Script"}, true},
+ {"aborted", NetworkEntry{Failed: true, Error: "net::ERR_ABORTED", ResourceType: "Image"}, true},
+ {"in-flight", NetworkEntry{ResourceType: "Image"}, false},
+ }
+ for _, tc := range cases {
+ if got := IsBrokenAsset(tc.entry); got != tc.want {
+ t.Errorf("%s: IsBrokenAsset = %v, want %v", tc.name, got, tc.want)
+ }
+ }
+}
+
+func TestBrokenAssetsClassification(t *testing.T) {
+ entries := []NetworkEntry{
+ {URL: "http://fixtures/audit-site/index.html", Status: 200, ResourceType: "Document", Finished: true},
+ {URL: "http://fixtures/audit-site/assets/missing.png", Status: 404, ResourceType: "Image", Finished: true},
+ {URL: "http://fixtures/audit-site/assets/missing.json", Status: 404, ResourceType: "Fetch", Finished: true},
+ {URL: "http://fixtures/api", Failed: true, Error: "net::ERR_FAILED", ResourceType: "XHR"},
+ }
+
+ got := BrokenAssets(entries)
+ want := []BrokenAsset{
+ {URL: "http://fixtures/audit-site/assets/missing.png", ResourceType: "image", StatusCode: 404},
+ {URL: "http://fixtures/audit-site/assets/missing.json", ResourceType: "fetch", StatusCode: 404},
+ {URL: "http://fixtures/api", ResourceType: "xhr", StatusCode: 0, Error: "net::ERR_FAILED"},
+ }
+ if !reflect.DeepEqual(got, want) {
+ t.Errorf("BrokenAssets:\n got %+v\nwant %+v", got, want)
+ }
+}
+
+func TestBrokenAssetsEmpty(t *testing.T) {
+ got := BrokenAssets([]NetworkEntry{{URL: "http://fixtures/clean.html", Status: 200, ResourceType: "Document", Finished: true}})
+ if len(got) != 0 {
+ t.Errorf("BrokenAssets on clean entries = %+v, want empty", got)
+ }
+ if got == nil {
+ t.Error("BrokenAssets should return an empty slice, not nil (JSON [])")
+ }
+}
diff --git a/internal/handlers/network.go b/internal/handlers/network.go
index 29985d1a..d35f2355 100644
--- a/internal/handlers/network.go
+++ b/internal/handlers/network.go
@@ -10,6 +10,7 @@ import (
"time"
"github.com/pinchtab/pinchtab/internal/bridge"
+ "github.com/pinchtab/pinchtab/internal/bridge/observe"
"github.com/pinchtab/pinchtab/internal/httpx"
)
@@ -206,6 +207,7 @@ func populateLiveBodyResult(result map[string]any, body string, base64Encoded bo
// @Param status string query Status code range filter e.g. "4xx", "5xx", "200" (optional)
// @Param type string query Resource type filter e.g. "xhr", "fetch", "document" (optional)
// @Param limit int query Maximum entries to return (optional)
+// @Param broken bool query Return only broken assets (status >= 400 or failed) as {url,resourceType,statusCode} (optional)
// @Param bufferSize int query Buffer size for new capture (optional, default from config)
//
// @Response 200 application/json List of network entries
@@ -249,6 +251,16 @@ func (h *Handlers) HandleNetwork(w http.ResponseWriter, r *http.Request) {
entries = entries[len(entries)-filter.Limit:]
}
+ if parseBoolQuery(r.URL.Query().Get("broken")) {
+ broken := observe.BrokenAssets(entries)
+ httpx.JSON(w, 200, map[string]any{
+ "broken": broken,
+ "count": len(broken),
+ "tabId": resolvedTabID,
+ })
+ return
+ }
+
httpx.JSON(w, 200, map[string]any{
"entries": entries,
"items": entries,
diff --git a/tests/e2e/scenarios/api/broken-assets-basic.sh b/tests/e2e/scenarios/api/broken-assets-basic.sh
new file mode 100755
index 00000000..c9e353a2
--- /dev/null
+++ b/tests/e2e/scenarios/api/broken-assets-basic.sh
@@ -0,0 +1,70 @@
+#!/bin/bash
+# broken-assets-basic.sh — GET /network?broken=true broken asset detection.
+
+GROUP_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${GROUP_DIR}/../../helpers/api.sh"
+
+# Polls /network?broken=true until at least $1 broken entries appear (the
+# page's subresource failures land asynchronously after navigate returns).
+wait_for_broken_count() {
+ local want="$1"
+ local tries=0
+ while [ "$tries" -lt 20 ]; do
+ pt_get "/network?broken=true"
+ local count
+ count=$(echo "$RESULT" | jq '.broken | length')
+ if [ "$count" -ge "$want" ]; then
+ return 0
+ fi
+ tries=$((tries + 1))
+ sleep 0.3
+ done
+ return 1
+}
+
+# ─────────────────────────────────────────────────────────────────
+start_test "broken-assets page reports 3 asset 404s and the failed fetch"
+
+pt_post /network/clear ''
+pt_post /navigate -d "{\"url\":\"${FIXTURES_URL}/audit-site/broken-assets.html\"}"
+assert_ok "navigate to broken-assets.html"
+
+if wait_for_broken_count 4; then
+ pass_assert "broken entries appeared"
+else
+ fail_assert "broken entries did not reach 4 (got: $(echo "$RESULT" | jq '.broken | length'))"
+fi
+
+assert_json_length "$RESULT" '.broken' 4 "exactly 4 broken entries"
+
+assert_json_eq "$RESULT" '[.broken[] | select(.url | endswith("assets/missing.css"))][0].resourceType' "stylesheet" "missing.css classified as stylesheet"
+assert_json_eq "$RESULT" '[.broken[] | select(.url | endswith("assets/missing.css"))][0].statusCode' "404" "missing.css is 404"
+assert_json_eq "$RESULT" '[.broken[] | select(.url | endswith("assets/missing.js"))][0].resourceType' "script" "missing.js classified as script"
+assert_json_eq "$RESULT" '[.broken[] | select(.url | endswith("assets/missing.js"))][0].statusCode' "404" "missing.js is 404"
+assert_json_eq "$RESULT" '[.broken[] | select(.url | endswith("assets/missing.png"))][0].resourceType' "image" "missing.png classified as image"
+assert_json_eq "$RESULT" '[.broken[] | select(.url | endswith("assets/missing.png"))][0].statusCode' "404" "missing.png is 404"
+
+FETCH_TYPE=$(echo "$RESULT" | jq -r '[.broken[] | select(.url | endswith("assets/missing.json"))][0].resourceType')
+if [ "$FETCH_TYPE" = "fetch" ] || [ "$FETCH_TYPE" = "xhr" ]; then
+ pass_assert "missing.json classified as xhr/fetch (got: $FETCH_TYPE)"
+else
+ fail_assert "missing.json classified as xhr/fetch (got: $FETCH_TYPE)"
+fi
+assert_json_eq "$RESULT" '[.broken[] | select(.url | endswith("assets/missing.json"))][0].statusCode' "404" "missing.json is 404"
+
+end_test
+
+# ─────────────────────────────────────────────────────────────────
+start_test "clean page reports no broken assets"
+
+pt_post /network/clear ''
+pt_post /navigate -d "{\"url\":\"${FIXTURES_URL}/audit-site/clean.html\"}"
+assert_ok "navigate to clean.html"
+
+sleep 1
+pt_get "/network?broken=true"
+assert_ok "get broken assets"
+assert_json_length "$RESULT" '.broken' 0 "broken list empty"
+assert_json_eq "$RESULT" '.count' "0" "count is 0"
+
+end_test