feat: add lite command for interactive/headless browser-based evidence collection with screenshot metadata overlay.

Author: canaria-computer

cmd/lite.go

@@ -5,6 +5,7 @@ package cmd
 
 import (
 	"bytes"
+	"encoding/base64"
 	"fmt"
 	"image"
 	"image/color"
@@ -63,7 +64,10 @@ Supports interactive mode for pages requiring manual interaction (e.g., CAPTCHA,
 		// 3. Create Base Report Directory (Common)
 		reportID := cfg.ReportID
 		if reportID == "" {
-			reportID = fmt.Sprintf("report-%s", time.Now().Format("20060102-150405"))
+			// User requested Base64 representation of the date value
+			ts := time.Now().Format("20060102-150405")
+			encoded := base64.RawURLEncoding.EncodeToString([]byte(ts))
+			reportID = fmt.Sprintf("report-%s", encoded)
 		}
 		if err := os.MkdirAll(reportID, 0755); err != nil {
 			log.Fatalf("Failed to create report directory: %v", err)
@@ -242,108 +246,137 @@ func saveScreenshot(data []byte, targetURL string, userAgent string, outputDir s
 }
 
 func addHeaderToImage(baseImg image.Image, info *utils.AccessInfo, TargetURL *string, userAgent string) (image.Image, error) {
+	// Fixed width for standard output
+	const fixedWidth = 1920
+
 	bounds := baseImg.Bounds()
-	width := bounds.Dx()
-	height := bounds.Dy()
+	screenshotWidth := bounds.Dx()
+	screenshotHeight := bounds.Dy()
+
+	// Create final image with fixed width.
+	// The height will be determined later, but width is always 1920.
+	// We need to calculate text wrapping based on 1920px.
 
-	// Calculate available width for text (with margins)
 	textMarginX := 10
-	availableWidth := width - (textMarginX * 2)
+	availableWidth := fixedWidth - (textMarginX * 2)
 	charWidth := 8 // inconsolata.Regular8x16 character width
 
-	// Wrap User-Agent to fit width without truncation
+	// Wrap User-Agent to fit fixed width
 	maxCharsPerLine := availableWidth / charWidth
 	if maxCharsPerLine < 20 {
 		maxCharsPerLine = 20
-	} // Safety
+	}
+
+	// We can use simple wrapping now because we have plenty of space (1920px)
 	uaLines := wrapText(userAgent, maxCharsPerLine)
 
 	now := info.Timestamp.UTC().Format(time.RFC3339)
 
-	// Parse and format URL with Punycode/IDN handling
+	// URL parsing
 	targetURL := *TargetURL
 	parsedURL, err := url.Parse(targetURL)
 	if err != nil {
 		log.Warnf("Failed to parse target URL: %v", err)
 		parsedURL = &url.URL{Host: "invalid-url"}
 	}
-
-	// Convert host to Punycode (ASCII) form for display
 	punycodeHost := parsedURL.Host
 	if parsedURL.Host != "" {
-		asciiHost, err := idna.ToASCII(parsedURL.Host)
-		if err != nil {
-			log.Warnf("IDNA ToASCII conversion failed for host %s: %v", parsedURL.Host, err)
-		} else {
+		if asciiHost, err := idna.ToASCII(parsedURL.Host); err == nil {
 			punycodeHost = asciiHost
 		}
 	}
-
-	// Build origin (scheme + host + port in Punycode)
 	origin := fmt.Sprintf("%s://%s", parsedURL.Scheme, punycodeHost)
-
-	// Build full URL with Punycode host
 	fullURLCopy := *parsedURL
 	fullURLCopy.Host = punycodeHost
 	fullURL := fullURLCopy.String()
 
-	// Truncate URLs if needed
-	maxOriginLen := maxCharsPerLine - 14 // "Origin:       " length
+	// Truncate URLs (using fixed width context, so usually no truncation needed)
+	maxOriginLen := maxCharsPerLine - 14
 	maxFullURLLen := maxCharsPerLine - 14
 	truncatedOrigin := truncateString(origin, maxOriginLen)
 	truncatedFullURL := truncateString(fullURL, maxFullURLLen)
 
 	// Build lines array
 	lines := []string{
 		fmt.Sprintf("Access Information (down-force demo) - %s", now),
-		"--------------------------------------------------------------------------------",
+		string(bytes.Repeat([]byte("-"), maxCharsPerLine)), // Dynamic separator for 1920px
 		fmt.Sprintf("Origin:       %s", truncatedOrigin),
 		fmt.Sprintf("Full URL:     %s", truncatedFullURL),
 	}
 
-	// Add User-Agent with wrapping (no truncation)
 	if len(uaLines) > 0 {
 		lines = append(lines, "User-Agent:   "+uaLines[0])
 		for i := 1; i < len(uaLines); i++ {
-			lines = append(lines, "              "+uaLines[i]) // Indent continuation lines
+			lines = append(lines, "              "+uaLines[i])
 		}
 	} else {
 		lines = append(lines, "User-Agent:   "+userAgent)
 	}
 
-	lines = append(lines,
-		"--------------------------------------------------------------------------------",
-		fmt.Sprintf("IPv4 Address: %s", info.FromIPv4),
-	)
+	lines = append(lines, string(bytes.Repeat([]byte("-"), maxCharsPerLine)))
+
+	// Helper to wrap generic text (even with 1920px, very long strings might need wrapping)
+	wrapField := func(label, value string) {
+		fullLine := fmt.Sprintf("%s%s", label, value)
+		if len([]rune(fullLine)) <= maxCharsPerLine {
+			lines = append(lines, fullLine)
+		} else {
+			lines = append(lines, wrapText(fullLine, maxCharsPerLine)...)
+		}
+	}
+
+	wrapField("IPv4 Address: ", info.FromIPv4)
 	if info.FromIPv6 != "" {
-		lines = append(lines, fmt.Sprintf("IPv6 Address: %s", info.FromIPv6))
+		wrapField("IPv6 Address: ", info.FromIPv6)
 	}
-	lines = append(lines,
-		fmt.Sprintf("Location:     %s", info.Country),
-		fmt.Sprintf("ISP:          %s", info.ISP),
-		fmt.Sprintf("ASN:          %s", info.ASN),
-		"--------------------------------------------------------------------------------",
-	)
-
-	// Calculate header height based on line count
+	wrapField("Location:     ", info.Country)
+	wrapField("ISP:          ", info.ISP)
+	wrapField("ASN:          ", info.ASN)
+
+	lines = append(lines, string(bytes.Repeat([]byte("-"), maxCharsPerLine)))
+
+	// Calculate dimensions
 	lineHeight := 16
 	startY := 20
 	headerHeight := startY + (len(lines) * lineHeight) + 10
 
-	// Create new image with calculated header height
-	newImg := image.NewRGBA(image.Rect(0, 0, width, height+headerHeight))
+	// Validate minimal width (screenshot might be wider than 1920? unlikely for mobile but possible for 4k desktop)
+	// User said "Always fixed 1920px". If screenshot > 1920, we should probably crop or resize or expand.
+	// Usually "Standard Evidence" implies 1920 is the canvas. If screenshot is bigger, the canvas grows?
+	// But user said "Always fix width to 1920px". So if screenshot > 1920, we might need to downscale or let it crop?
+	// Safer assumption: Canvas Width = Max(1920, ScreenshotWidth). But user said "Fixed 1920".
+	// Let's stick to 1920. If screenshot is larger, it gets cropped. But mobile is usually smaller.
+
+	finalWidth := fixedWidth
+
+	newImg := image.NewRGBA(image.Rect(0, 0, finalWidth, headerHeight+screenshotHeight))
 
-	headerRect := image.Rect(0, 0, width, headerHeight)
-	draw.Draw(newImg, headerRect, image.NewUniform(color.Black), image.Point{}, draw.Src)
+	// 1. Draw Header Background (Black) - Full Width
+	draw.Draw(newImg, image.Rect(0, 0, finalWidth, headerHeight), image.NewUniform(color.Black), image.Point{}, draw.Src)
 
-	draw.Draw(
-		newImg,
-		image.Rect(0, headerHeight, width, headerHeight+height),
-		baseImg,
-		image.Point{},
-		draw.Src,
-	)
+	// 2. Draw Screenshot - Centered horizontally at the bottom
+	// Calculate center X
+	// If screenshotWidth < 1920: (1920 - w) / 2
+	// If screenshotWidth > 1920: (1920 - w) / 2 (result is negative, drawing starts at negative, effectively cropping center)
 
+	var dstX int
+	if screenshotWidth < finalWidth {
+		dstX = (finalWidth - screenshotWidth) / 2
+	} else {
+		// Center crop behavior implies dstX is negative?
+		// Wait, user wants "padding" for mobile (narrow).
+		// For wide, if I fix 1920, I must crop or resize. I'll center.
+		dstX = (finalWidth - screenshotWidth) / 2
+	}
+
+	// Draw screenshot
+	// Transparent padding is achieved because newImg is zero-initialized (transparent distinct from black).
+	// We only filled the header rect with Black. The rest is transparent.
+
+	screenshotRect := image.Rect(dstX, headerHeight, dstX+screenshotWidth, headerHeight+screenshotHeight)
+	draw.Draw(newImg, screenshotRect, baseImg, image.Point{}, draw.Src)
+
+	// 3. Draw Header Text
 	face := inconsolata.Regular8x16
 	d := &font.Drawer{
 		Dst:  newImg,
@@ -352,7 +385,6 @@ func addHeaderToImage(baseImg image.Image, info *utils.AccessInfo, TargetURL *st
 	}
 
 	startX := textMarginX
-
 	for i, line := range lines {
 		d.Dot = fixed.Point26_6{
 			X: fixed.I(startX),
@@ -361,7 +393,7 @@ func addHeaderToImage(baseImg image.Image, info *utils.AccessInfo, TargetURL *st
 		d.DrawString(line)
 	}
 
-	log.Infof("Header added to screenshot: origin=%s, full_url=%s, ua=%s", truncatedOrigin, truncatedFullURL, userAgent)
+	log.Infof("Header added with fixed width %d: origin=%s", finalWidth, truncatedOrigin)
 
 	return newImg, nil
 }