codehava-agent-kit 1.0.1 → 3.0.0

package/templates/.agent/skills/go-rod-master/examples/concurrent_pages.go

@@ -0,0 +1,81 @@
+package main
+
+import (
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/go-rod/rod"
+	"github.com/go-rod/stealth"
+)
+
+// concurrent_pages demonstrates using rod.PagePool for concurrent scraping
+// with stealth-enabled pages.
+func main() {
+	browser := rod.New().
+		Timeout(2 * time.Minute).
+		MustConnect()
+	defer browser.MustClose()
+
+	// URLs to scrape concurrently
+	urls := []string{
+		"https://example.com",
+		"https://example.org",
+		"https://www.iana.org/domains/reserved",
+		"https://www.iana.org/about",
+	}
+
+	// Create a page pool with max 3 concurrent pages
+	pool := rod.NewPagePool(3)
+
+	// Factory function: creates stealth-enabled pages in isolated incognito contexts
+	create := func() *rod.Page {
+		// MustIncognito creates an isolated browser context (separate cookies, storage)
+		page := stealth.MustPage(browser.MustIncognito())
+		return page
+	}
+
+	// Collect results safely using a mutex
+	var mu sync.Mutex
+	results := make(map[string]string)
+
+	// Scrape all URLs concurrently
+	var wg sync.WaitGroup
+	for _, url := range urls {
+		wg.Add(1)
+		go func(u string) {
+			defer wg.Done()
+
+			// Get a page from the pool (blocks if pool is full)
+			page := pool.MustGet(create)
+			defer pool.Put(page) // return page to pool when done
+
+			// Navigate and wait for the page to stabilize
+			page.MustNavigate(u).MustWaitStable()
+
+			// Extract the page title
+			title := page.MustInfo().Title
+
+			// Store result
+			mu.Lock()
+			results[u] = title
+			mu.Unlock()
+
+			fmt.Printf("[done] %s → %s\n", u, title)
+		}(url)
+	}
+
+	// Wait for all goroutines to complete
+	wg.Wait()
+
+	// Clean up the pool
+	pool.Cleanup(func(p *rod.Page) {
+		p.MustClose()
+	})
+
+	// Print summary
+	fmt.Printf("\n--- Results (%d pages scraped) ---\n", len(results))
+	for url, title := range results {
+		fmt.Printf("  %s: %s\n", url, title)
+	}
+}

package/templates/.agent/skills/go-rod-master/examples/request_hijacking.go

@@ -0,0 +1,85 @@
+package main
+
+import (
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/go-rod/rod"
+	"github.com/go-rod/rod/lib/proto"
+	"github.com/go-rod/stealth"
+)
+
+// request_hijacking demonstrates intercepting and modifying network requests
+// using Rod's HijackRequests API.
+func main() {
+	browser := rod.New().
+		Timeout(time.Minute).
+		MustConnect()
+	defer browser.MustClose()
+
+	// --- Example 1: Block image requests to save bandwidth ---
+	router := browser.HijackRequests()
+	defer router.MustStop()
+
+	// Block all PNG and JPEG image requests
+	router.MustAdd("*.png", func(ctx *rod.Hijack) {
+		ctx.Response.Fail(proto.NetworkErrorReasonBlockedByClient)
+	})
+	router.MustAdd("*.jpg", func(ctx *rod.Hijack) {
+		ctx.Response.Fail(proto.NetworkErrorReasonBlockedByClient)
+	})
+
+	// Modify request headers for API calls
+	router.MustAdd("*api.*", func(ctx *rod.Hijack) {
+		ctx.Request.Req().Header.Set("X-Custom-Header", "go-rod")
+		ctx.Request.Req().Header.Set("Authorization", "Bearer my-token")
+
+		// Load the actual response from the server
+		if err := ctx.LoadResponse(http.DefaultClient, true); err != nil {
+			fmt.Printf("Failed to load response: %v\n", err)
+			return
+		}
+
+		fmt.Printf("API response status: %d\n", ctx.Response.Payload().ResponseCode)
+	})
+
+	// Inject JavaScript into every JS file loaded
+	router.MustAdd("*.js", func(ctx *rod.Hijack) {
+		if err := ctx.LoadResponse(http.DefaultClient, true); err != nil {
+			return
+		}
+		// Append tracking code to all JavaScript files
+		body := ctx.Response.Body()
+		ctx.Response.SetBody(body + "\n// Monitored by go-rod")
+	})
+
+	// IMPORTANT: Start the router in a goroutine
+	go router.Run()
+
+	// Use stealth page for anti-detection
+	page := stealth.MustPage(browser)
+	page.MustNavigate("https://example.com").MustWaitLoad()
+
+	fmt.Println("Page loaded with request hijacking active")
+	fmt.Println("Title:", page.MustElement("title").MustText())
+
+	// --- Example 2: Capture and log all network requests ---
+	// (Using a separate page to show different patterns)
+	page2 := stealth.MustPage(browser)
+
+	// Enable network domain for request logging
+	proto.NetworkEnable{}.Call(page2)
+
+	// Listen for network responses
+	go page2.EachEvent(func(e *proto.NetworkResponseReceived) {
+		fmt.Printf("  [%d] %s %s\n",
+			e.Response.Status,
+			e.Type.String(),
+			e.Response.URL,
+		)
+	})()
+
+	page2.MustNavigate("https://example.com").MustWaitLoad()
+	fmt.Println("\nNetwork log above shows all requests captured")
+}

package/templates/.agent/skills/go-rod-master/examples/stealth_page.go

@@ -0,0 +1,91 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/go-rod/rod"
+	"github.com/go-rod/rod/lib/launcher"
+	"github.com/go-rod/rod/lib/utils"
+	"github.com/go-rod/stealth"
+)
+
+// stealth_page demonstrates using go-rod/stealth to bypass bot detection.
+// It creates a stealth-enabled page and verifies evasions against a detection site.
+func main() {
+	// Ensure the browser binary is downloaded
+	launcher.NewBrowser().MustGet()
+
+	// Launch browser with custom launcher settings
+	url := launcher.New().
+		Headless(true).
+		MustLaunch()
+
+	browser := rod.New().
+		ControlURL(url).
+		Timeout(time.Minute).
+		MustConnect()
+	defer browser.MustClose()
+
+	// CRITICAL: Use stealth.MustPage instead of browser.MustPage
+	// This injects anti-detection JavaScript into every new document
+	page := stealth.MustPage(browser)
+
+	// Navigate to a bot detection test page
+	page.MustNavigate("https://bot.sannysoft.com")
+
+	// Wait for the detection tests to complete
+	page.MustElement("#broken-image-dimensions.passed")
+
+	// Take a screenshot to verify results
+	page.MustScreenshot("stealth_result.png")
+	fmt.Println("Screenshot saved to stealth_result.png")
+
+	// Print detection results
+	printBotDetectionReport(page)
+
+	// ---- Advanced: Using stealth.JS directly ----
+	// If you need to create the page manually (e.g., with specific context),
+	// you can inject stealth.JS via EvalOnNewDocument:
+	advancedPage := browser.MustPage()
+	advancedPage.MustEvalOnNewDocument(stealth.JS)
+	advancedPage.MustNavigate("https://bot.sannysoft.com")
+	advancedPage.MustElement("#broken-image-dimensions.passed")
+	fmt.Println("\nAdvanced stealth page also passed detection tests")
+
+	// ---- Production: Error handling pattern ----
+	prodPage, err := stealth.Page(browser)
+	if err != nil {
+		fmt.Printf("Failed to create stealth page: %v\n", err)
+		return
+	}
+	prodPage.MustNavigate("https://example.com")
+	title, err := prodPage.MustElement("title").Text()
+	if err != nil {
+		fmt.Printf("Failed to get title: %v\n", err)
+		return
+	}
+	fmt.Printf("\nProduction page title: %s\n", title)
+}
+
+// printBotDetectionReport extracts and prints the detection test results.
+func printBotDetectionReport(page *rod.Page) {
+	el := page.MustElement("#broken-image-dimensions.passed")
+	for _, row := range el.MustParents("table").First().MustElements("tr:nth-child(n+2)") {
+		cells := row.MustElements("td")
+		key := cells[0].MustProperty("textContent")
+
+		if strings.HasPrefix(key.String(), "User Agent") {
+			ua := cells[1].MustProperty("textContent").String()
+			passed := !strings.Contains(ua, "HeadlessChrome/")
+			fmt.Printf("  %s: %t\n", key, passed)
+		} else if strings.HasPrefix(key.String(), "Hairline Feature") {
+			continue // machine-dependent, skip
+		} else {
+			fmt.Printf("  %s: %s\n", key, cells[1].MustProperty("textContent"))
+		}
+	}
+
+	_ = utils.OutputFile("stealth_result.png", []byte{})
+}

package/templates/.agent/skills/go-rod-master/references/api-reference.md

@@ -0,0 +1,148 @@
+# Go-Rod API Quick Reference
+
+Cheat sheet for the most-used `go-rod/rod` and `go-rod/stealth` APIs.
+Every `Must*` method has a corresponding error-returning version (without the `Must` prefix).
+
+---
+
+## Browser (`rod.Browser`)
+
+| Method | Description |
+|:-------|:------------|
+| `rod.New().MustConnect()` | Launch new browser and connect |
+| `rod.New().ControlURL(url).MustConnect()` | Connect to existing browser via WebSocket URL |
+| `browser.MustClose()` | Close browser and all pages |
+| `browser.MustPage(url)` | Create new page (tab) and navigate |
+| `browser.MustPage()` | Create blank page |
+| `browser.MustIncognito()` | Create isolated incognito context |
+| `browser.MustIgnoreCertErrors(true)` | Ignore SSL certificate errors |
+| `browser.MustHandleAuth(user, pass)` | Handle HTTP basic/proxy auth |
+| `browser.HijackRequests()` | Create request interceptor router |
+| `browser.MustWaitDownload()` | Wait for a file download to complete |
+| `browser.ServeMonitor("")` | Start visual monitoring server |
+| `browser.Trace(true)` | Enable verbose tracing |
+| `browser.SlowMotion(duration)` | Add delay between actions |
+| `rod.NewPagePool(n)` | Create pool of max `n` reusable pages |
+| `rod.NewBrowserPool(n)` | Create pool of max `n` reusable browsers |
+
+## Page (`rod.Page`)
+
+| Method | Description |
+|:-------|:------------|
+| `page.MustNavigate(url)` | Navigate to URL |
+| `page.MustWaitLoad()` | Wait for `load` event |
+| `page.MustWaitStable()` | Wait until page DOM is stable |
+| `page.MustWaitRequestIdle()` | Wait until no pending network requests |
+| `page.MustWaitIdle()` | Wait for both load and request idle |
+| `page.MustWait(js)` | Wait for JS expression to return truthy |
+| `page.MustElement(selector)` | Find element by CSS selector (auto-wait) |
+| `page.MustElementR(selector, regex)` | Find element by CSS + text regex |
+| `page.MustElementX(xpath)` | Find element by XPath |
+| `page.MustElements(selector)` | Find all matching elements |
+| `page.MustSearch(query)` | Search across iframes + shadow DOM |
+| `page.MustEval(js, args...)` | Execute JavaScript on page |
+| `page.MustEvalOnNewDocument(js)` | Inject JS before any page script runs |
+| `page.MustScreenshot(path)` | Take PNG screenshot |
+| `page.MustPDF(path)` | Export page as PDF |
+| `page.ScrollScreenshot(opts)` | Full-page scroll screenshot |
+| `page.MustInfo()` | Get page info (title, URL) |
+| `page.Timeout(duration)` | Set timeout for chained operations |
+| `page.CancelTimeout()` | Remove timeout for subsequent operations |
+| `page.Race()` | Start race selector (multiple outcomes) |
+| `page.Keyboard` | Access keyboard controller |
+| `page.Mouse` | Access mouse controller |
+| `page.WaitEvent(proto)` | Wait for specific CDP event |
+| `page.EachEvent(handler)` | Subscribe to events continuously |
+| `page.Event()` | Channel-based event stream |
+
+## Element (`rod.Element`)
+
+| Method | Description |
+|:-------|:------------|
+| `el.MustClick()` | Click the element |
+| `el.MustInput(text)` | Clear and type text into input |
+| `el.MustType(keys...)` | Simulate key presses |
+| `el.MustText()` | Get text content |
+| `el.MustHTML()` | Get outer HTML |
+| `el.MustProperty(name)` | Get JS property value |
+| `el.MustAttribute(name)` | Get HTML attribute value |
+| `el.MustWaitStable()` | Wait until position/size stable |
+| `el.MustWaitVisible()` | Wait until element is visible |
+| `el.MustWaitInvisible()` | Wait until element is hidden |
+| `el.MustParents(selector)` | Find parent elements matching selector |
+| `el.MustElements(selector)` | Find child elements |
+| `el.MustMatches(selector)` | Check if element matches selector |
+| `el.MustEval(js)` | Eval JS with `this` = element |
+| `el.MustScreenshot(path)` | Screenshot just this element |
+
+## Input (`rod/lib/input`)
+
+| Constant | Description |
+|:---------|:------------|
+| `input.Enter` | Enter key |
+| `input.Escape` | Escape key |
+| `input.Tab` | Tab key |
+| `input.Slash` | `/` key |
+| `input.ControlLeft` | Left Ctrl |
+| `input.ShiftLeft` | Left Shift |
+| `input.KeyA` — `input.KeyZ` | Letter keys |
+| `input.MouseLeft` | Left mouse button |
+
+## Launcher (`rod/lib/launcher`)
+
+| Method | Description |
+|:-------|:------------|
+| `launcher.New()` | Create new launcher |
+| `l.Headless(bool)` | Enable/disable headless mode |
+| `l.Devtools(bool)` | Auto-open DevTools |
+| `l.Proxy(addr)` | Set proxy server |
+| `l.Set(flag, value)` | Set Chrome CLI flag |
+| `l.Delete(flag)` | Remove Chrome CLI flag |
+| `l.MustLaunch()` | Launch browser, return control URL |
+| `l.Cleanup()` | Kill browser process |
+| `launcher.NewBrowser().MustGet()` | Download browser binary |
+| `launcher.Open(url)` | Open URL in system browser |
+
+## Stealth (`go-rod/stealth`)
+
+| API | Description |
+|:----|:------------|
+| `stealth.MustPage(browser)` | Create stealth page (panics on error) |
+| `stealth.Page(browser)` | Create stealth page (returns error) |
+| `stealth.JS` | Raw JS string with all stealth evasions |
+
+**What stealth.JS injects:**
+- Removes `navigator.webdriver` detection
+- Spoofs WebGL vendor/renderer to real GPU values
+- Fixes Chrome plugin array (`PluginArray` type, count=3)
+- Patches permissions API (returns `"prompt"`)
+- Sets realistic languages (`en-US,en`)
+- Fixes broken image dimensions (16x16 instead of 0x0)
+
+## Network Hijacking (`rod.Hijack`)
+
+| Method | Description |
+|:-------|:------------|
+| `router.MustAdd(pattern, handler)` | Add URL pattern handler |
+| `router.Run()` | Start intercepting (call with `go`) |
+| `router.MustStop()` | Stop intercepting |
+| `ctx.Request.Req()` | Access `*http.Request` |
+| `ctx.Request.URL()` | Get request URL |
+| `ctx.LoadResponse(client, true)` | Load response from server |
+| `ctx.MustLoadResponse()` | Load response (panics on error) |
+| `ctx.Response.Body()` | Get response body |
+| `ctx.Response.SetBody(s)` | Modify response body |
+| `ctx.Response.Fail(reason)` | Block the request |
+| `ctx.Response.Payload()` | Get response metadata |
+
+## Direct CDP (`rod/lib/proto`)
+
+```go
+// Call any CDP method directly
+proto.PageSetAdBlockingEnabled{Enabled: true}.Call(page)
+
+// Or via generic JSON API
+page.Call(ctx, "", "Page.setAdBlockingEnabled", map[string]bool{"enabled": true})
+```
+
+Full CDP protocol reference: https://chromedevtools.github.io/devtools-protocol/