Skip to content

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

4.8 KB
Raw Blame
package actions

import (
	"bufio"
	"encoding/json"
	"fmt"
	"net/http"
	"net/url"
	"os"
	"strings"

	"github.com/pinchtab/pinchtab/internal/cli/apiclient"
	"github.com/pinchtab/pinchtab/internal/sanitize"
	"github.com/spf13/cobra"
)

// Network lists recent network requests.
func Network(client *http.Client, base, token string, cmd *cobra.Command, args []string) {
	// If a positional arg is given, treat it as a requestId detail lookup
	if len(args) > 0 {
		NetworkDetail(client, base, token, cmd, args[0])
		return
	}

	if v, _ := cmd.Flags().GetBool("clear"); v {
		NetworkClear(client, base, token, cmd)
		return
	}

	if v, _ := cmd.Flags().GetBool("stream"); v {
		NetworkStream(client, base, token, cmd)
		return
	}

	params := url.Values{}
	if v, _ := cmd.Flags().GetString("tab"); v != "" {
		params.Set("tabId", v)
	}
	if v, _ := cmd.Flags().GetString("filter"); v != "" {
		params.Set("filter", v)
	}
	if v, _ := cmd.Flags().GetString("method"); v != "" {
		params.Set("method", v)
	}
	if v, _ := cmd.Flags().GetString("status"); v != "" {
		params.Set("status", v)
	}
	if v, _ := cmd.Flags().GetString("type"); v != "" {
		params.Set("type", v)
	}
	if v, _ := cmd.Flags().GetString("limit"); v != "" {
		params.Set("limit", v)
	}
	if v, _ := cmd.Flags().GetString("buffer-size"); v != "" {
		params.Set("bufferSize", v)
	}

	jsonOutput, _ := cmd.Flags().GetBool("json")
	if jsonOutput {
		apiclient.DoGet(client, base, token, "/network", params)
		return
	}

	body := apiclient.DoGetRaw(client, base, token, "/network", params)
	var resp struct {
		Count   int `json:"count"`
		Entries []struct {
			Method string `json:"method"`
			Status int    `json:"status"`
			URL    string `json:"url"`
		} `json:"entries"`
	}
	if err := json.Unmarshal(body, &resp); err != nil {
		fmt.Println(string(body))
		return
	}
	if resp.Count == 0 {
		fmt.Println("No requests captured")
		return
	}
	for _, e := range resp.Entries {
		fmt.Printf("%-6s %3d  %s\n", e.Method, e.Status, sanitize.TruncateUTF8BytesWithEllipsis(e.URL, networkURLDisplayMaxBytes))
	}
}

// networkURLDisplayMaxBytes is the TOTAL byte budget for a URL in the terminal
// listing, marker included — the same total the hand-rolled cut produced (77
// bytes plus a 3-byte marker), so the column width is unchanged.
const networkURLDisplayMaxBytes = 80

// NetworkDetail shows full details for a specific request.
func NetworkDetail(client *http.Client, base, token string, cmd *cobra.Command, requestID string) {
	params := url.Values{}
	if v, _ := cmd.Flags().GetString("tab"); v != "" {
		params.Set("tabId", v)
	}
	if v, _ := cmd.Flags().GetBool("body"); v {
		params.Set("body", "true")
	}
	path := fmt.Sprintf("/network/%s", url.PathEscape(requestID))
	apiclient.DoGet(client, base, token, path, params)
}

// NetworkClear clears captured network data.
func NetworkClear(client *http.Client, base, token string, cmd *cobra.Command) {
	params := url.Values{}
	if v, _ := cmd.Flags().GetString("tab"); v != "" {
		params.Set("tabId", v)
	}
	result := apiclient.DoPost(client, base, token, "/network/clear?"+params.Encode(), map[string]any{})
	if result == nil {
		fmt.Fprintln(os.Stderr, "Failed to clear network data")
	}
}

// NetworkStream connects to the SSE stream and prints entries as they arrive.
func NetworkStream(client *http.Client, base, token string, cmd *cobra.Command) {
	params := url.Values{}
	if v, _ := cmd.Flags().GetString("tab"); v != "" {
		params.Set("tabId", v)
	}
	if v, _ := cmd.Flags().GetString("filter"); v != "" {
		params.Set("filter", v)
	}
	if v, _ := cmd.Flags().GetString("method"); v != "" {
		params.Set("method", v)
	}
	if v, _ := cmd.Flags().GetString("status"); v != "" {
		params.Set("status", v)
	}
	if v, _ := cmd.Flags().GetString("type"); v != "" {
		params.Set("type", v)
	}
	if v, _ := cmd.Flags().GetString("buffer-size"); v != "" {
		params.Set("bufferSize", v)
	}

	u := base + "/network/stream"
	if len(params) > 0 {
		u += "?" + params.Encode()
	}

	req, err := http.NewRequest("GET", u, nil)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
		os.Exit(1)
	}
	if token != "" {
		req.Header.Set("Authorization", "Bearer "+token)
	}
	req.Header.Set("Accept", "text/event-stream")

	// Use a client without timeout for streaming
	streamClient := &http.Client{}
	resp, err := streamClient.Do(req)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error connecting to stream: %v\n", err)
		os.Exit(1)
	}
	defer resp.Body.Close() //nolint:errcheck // best-effort cleanup

	if resp.StatusCode != 200 {
		fmt.Fprintf(os.Stderr, "Error: HTTP %d\n", resp.StatusCode)
		os.Exit(1)
	}

	scanner := bufio.NewScanner(resp.Body)
	for scanner.Scan() {
		line := scanner.Text()
		if strings.HasPrefix(line, "data: ") {
			fmt.Println(line[6:])
		}
	}
	if err := scanner.Err(); err != nil {
		fmt.Fprintf(os.Stderr, "Stream error: %v\n", err)
		os.Exit(1)
	}
}