Fix cgo dependency 1367

pkg/utils/jsluice.go

@@ -1,4 +1,4 @@
-//go:build !(386 || windows)
+//go:build jsluice && !(386 || windows)
 
 package utils
 

pkg/utils/jsluice_stub.go

@@ -0,0 +1,86 @@
+//go:build !jsluice || 386 || windows
+
+package utils
+
+import (
+	"regexp"
+	"strings"
+)
+
+var (
+	// URL patterns for extracting endpoints from JavaScript
+	urlPattern = regexp.MustCompile(`(?i)(?:"|'|` + "`" + `)((?:https?:)?//[^\s"'` + "`" + `<>]+|/[^\s"'` + "`" + `<>]+)(?:"|'|` + "`" + `)`)
+
+	// API endpoint patterns
+	apiPattern = regexp.MustCompile(`(?i)(?:api|endpoint|url|path|route)[\s]*[:=][\s]*(?:"|'|` + "`" + `)([^"'` + "`" + `]+)(?:"|'|` + "`" + `)`)
+)
+
+type JSLuiceEndpoint struct {
+	Endpoint string
+	Type     string
+}
+
+// ExtractJsluiceEndpoints extracts endpoints from JavaScript using pure Go regex.
+// This is a fallback implementation when jsluice (which requires CGO) is not available.
+//
+// Note: This implementation uses regex patterns and may not be as accurate as jsluice,
+// but it eliminates the CGO dependency for cross-platform compilation.
+func ExtractJsluiceEndpoints(data string) []JSLuiceEndpoint {
+	var endpoints []JSLuiceEndpoint
+	seen := make(map[string]bool)
+
+	// Extract URLs using URL pattern
+	urlMatches := urlPattern.FindAllStringSubmatch(data, -1)
+	for _, match := range urlMatches {
+		if len(match) > 1 {
+			url := match[1]
+			if !seen[url] && isValidEndpoint(url) {
+				seen[url] = true
+				endpoints = append(endpoints, JSLuiceEndpoint{
+					Endpoint: url,
+					Type:     "url",
+				})
+			}
+		}
+	}
+
+	// Extract API endpoints
+	apiMatches := apiPattern.FindAllStringSubmatch(data, -1)
+	for _, match := range apiMatches {
+		if len(match) > 1 {
+			endpoint := match[1]
+			if !seen[endpoint] && isValidEndpoint(endpoint) {
+				seen[endpoint] = true
+				endpoints = append(endpoints, JSLuiceEndpoint{
+					Endpoint: endpoint,
+					Type:     "api",
+				})
+			}
+		}
+	}
+
+	return endpoints
+}
+
+// isValidEndpoint checks if the extracted string is a valid endpoint
+func isValidEndpoint(s string) bool {
+	// Filter out common false positives
+	if len(s) < 2 {
+		return false
+	}
+
+	// Normalize to lowercase for case-insensitive comparison
+	lower := strings.ToLower(s)
+
+	// Skip data URIs and javascript URIs
+	if strings.HasPrefix(lower, "data:") || strings.HasPrefix(lower, "javascript:") {
+		return false
+	}
+
+	// Skip very long strings (likely not URLs)
+	if len(s) > 2048 {
+		return false
+	}
+
+	return true
+}

pkg/utils/jsluice_stub_test.go

@@ -0,0 +1,112 @@
+//go:build !jsluice || 386 || windows
+
+package utils
+
+import (
+	"testing"
+)
+
+func TestExtractJsluiceEndpoints_Stub(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		wantURLs []string
+	}{
+		{
+			name:  "simple URL in quotes",
+			input: `var url = "https://example.com/api/users";`,
+			wantURLs: []string{
+				"https://example.com/api/users",
+			},
+		},
+		{
+			name:  "relative path",
+			input: `fetch("/api/data")`,
+			wantURLs: []string{
+				"/api/data",
+			},
+		},
+		{
+			name:  "multiple URLs",
+			input: `const api1 = "https://api.example.com/v1"; const api2 = "/api/v2/users";`,
+			wantURLs: []string{
+				"https://api.example.com/v1",
+				"/api/v2/users",
+			},
+		},
+		{
+			name:     "no URLs",
+			input:    `var x = 123; console.log("hello");`,
+			wantURLs: []string{},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			endpoints := ExtractJsluiceEndpoints(tt.input)
+
+			if len(tt.wantURLs) == 0 && len(endpoints) == 0 {
+				return
+			}
+
+			if len(endpoints) != len(tt.wantURLs) {
+				t.Errorf("ExtractJsluiceEndpoints() got %d endpoints, want %d", len(endpoints), len(tt.wantURLs))
+				return
+			}
+
+			// Check if all expected URLs are found
+			found := make(map[string]bool)
+			for _, ep := range endpoints {
+				found[ep.Endpoint] = true
+			}
+
+			for _, wantURL := range tt.wantURLs {
+				if !found[wantURL] {
+					t.Errorf("ExtractJsluiceEndpoints() missing expected URL: %s", wantURL)
+				}
+			}
+		})
+	}
+}
+
+func TestIsValidEndpoint(t *testing.T) {
+	tests := []struct {
+		name  string
+		input string
+		want  bool
+	}{
+		{
+			name:  "valid URL",
+			input: "https://example.com/api",
+			want:  true,
+		},
+		{
+			name:  "valid path",
+			input: "/api/users",
+			want:  true,
+		},
+		{
+			name:  "too short",
+			input: "/",
+			want:  false,
+		},
+		{
+			name:  "data URI",
+			input: "data:image/png;base64,iVBORw0KGgo...",
+			want:  false,
+		},
+		{
+			name:  "javascript URI",
+			input: "javascript:void(0)",
+			want:  false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := isValidEndpoint(tt.input); got != tt.want {
+				t.Errorf("isValidEndpoint() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}