Skip to content

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

feat: add POST /upload endpoint for file input handling

Mario35dc20ae6982
diff --git a/cmd/pinchtab/cmd_dashboard.go b/cmd/pinchtab/cmd_dashboard.go
index ebad25eb..63a6e986 100644
--- a/cmd/pinchtab/cmd_dashboard.go
+++ b/cmd/pinchtab/cmd_dashboard.go
@@ -58,7 +58,7 @@ func runDashboard(cfg *config.RuntimeConfig) {
"/tabs", "/snapshot", "/screenshot", "/text",
"/navigate", "/action", "/actions", "/evaluate",
"/tab", "/tab/lock", "/tab/unlock",
- "/cookies", "/download", "/stealth/status", "/fingerprint/rotate",
+ "/cookies", "/download", "/upload", "/stealth/status", "/fingerprint/rotate",
"/screencast", "/screencast/tabs",
}
for _, ep := range proxyEndpoints {
diff --git a/internal/handlers/handlers.go b/internal/handlers/handlers.go
index 4b8ca784..3209c5f5 100644
--- a/internal/handlers/handlers.go
+++ b/internal/handlers/handlers.go
@@ -46,6 +46,7 @@ func (h *Handlers) RegisterRoutes(mux *http.ServeMux, doShutdown func()) {
mux.HandleFunc("GET /stealth/status", h.HandleStealthStatus)
mux.HandleFunc("POST /fingerprint/rotate", h.HandleFingerprintRotate)
mux.HandleFunc("GET /download", h.HandleDownload)
+ mux.HandleFunc("POST /upload", h.HandleUpload)
mux.HandleFunc("GET /screencast", h.HandleScreencast)
mux.HandleFunc("GET /screencast/tabs", h.HandleScreencastAll)
mux.HandleFunc("GET /welcome", func(w http.ResponseWriter, r *http.Request) {
diff --git a/internal/handlers/upload.go b/internal/handlers/upload.go
new file mode 100644
index 00000000..2547e8ff
--- /dev/null
+++ b/internal/handlers/upload.go
@@ -0,0 +1,216 @@
+package handlers
+
+import (
+ "context"
+ "encoding/base64"
+ "encoding/json"
+ "fmt"
+ "net/http"
+ "os"
+ "strings"
+ "github.com/chromedp/cdproto/cdp"
+ "github.com/chromedp/cdproto/dom"
+ "github.com/chromedp/cdproto/runtime"
+ "github.com/chromedp/chromedp"
+ "github.com/pinchtab/pinchtab/internal/web"
+)
+
+type uploadRequest struct {
+ Selector string `json:"selector"`
+ Files []string `json:"files"`
+ Paths []string `json:"paths"`
+}
+
+// HandleUpload sets files on an <input type="file"> element via CDP.
+//
+// POST /upload?tabId=<id>
+//
+// {
+// "selector": "input[type=file]",
+// "files": ["data:image/png;base64,...", "base64:..."],
+// "paths": ["/tmp/photo.jpg"]
+// }
+//
+// Either "files" (base64 data) or "paths" (local file paths) must be provided.
+// Both can be combined. Files are written to a temp dir and passed to CDP.
+func (h *Handlers) HandleUpload(w http.ResponseWriter, r *http.Request) {
+ tabID := r.URL.Query().Get("tabId")
+
+ var req uploadRequest
+ if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+ web.Error(w, 400, fmt.Errorf("invalid JSON body: %w", err))
+ return
+ }
+
+ if req.Selector == "" {
+ req.Selector = "input[type=file]"
+ }
+
+ if len(req.Files) == 0 && len(req.Paths) == 0 {
+ web.Error(w, 400, fmt.Errorf("either 'files' (base64) or 'paths' (local paths) required"))
+ return
+ }
+
+ // Validate local paths exist.
+ for _, p := range req.Paths {
+ if _, err := os.Stat(p); err != nil {
+ web.Error(w, 400, fmt.Errorf("file not found: %s", p))
+ return
+ }
+ }
+
+ // Decode base64 files to temp dir.
+ var tempFiles []string
+ if len(req.Files) > 0 {
+ tmpDir, err := os.MkdirTemp("", "pinchtab-upload-*")
+ if err != nil {
+ web.Error(w, 500, fmt.Errorf("create temp dir: %w", err))
+ return
+ }
+ defer func() { _ = os.RemoveAll(tmpDir) }()
+
+ for i, f := range req.Files {
+ data, ext, err := decodeFileData(f)
+ if err != nil {
+ web.Error(w, 400, fmt.Errorf("file[%d]: %w", i, err))
+ return
+ }
+ path := fmt.Sprintf("%s/upload-%d%s", tmpDir, i, ext)
+ if err := os.WriteFile(path, data, 0644); err != nil {
+ web.Error(w, 500, fmt.Errorf("write temp file: %w", err))
+ return
+ }
+ tempFiles = append(tempFiles, path)
+ }
+ }
+
+ allPaths := append(tempFiles, req.Paths...)
+
+ ctx, _, err := h.Bridge.TabContext(tabID)
+ if err != nil {
+ web.Error(w, 404, err)
+ return
+ }
+
+ tCtx, tCancel := context.WithTimeout(ctx, h.Config.ActionTimeout)
+ defer tCancel()
+ go web.CancelOnClientDone(r.Context(), tCancel)
+
+ // Find the file input node and set files via CDP.
+ if err := chromedp.Run(tCtx,
+ chromedp.ActionFunc(func(ctx context.Context) error {
+ // Evaluate selector to get the DOM node.
+ nodeID, err := resolveSelector(ctx, req.Selector)
+ if err != nil {
+ return fmt.Errorf("selector %q: %w", req.Selector, err)
+ }
+ return dom.SetFileInputFiles(allPaths).WithNodeID(nodeID).Do(ctx)
+ }),
+ ); err != nil {
+ web.Error(w, 500, fmt.Errorf("upload: %w", err))
+ return
+ }
+
+ web.JSON(w, 200, map[string]any{
+ "status": "ok",
+ "files": len(allPaths),
+ })
+}
+
+// resolveSelector finds a DOM node by CSS selector and returns its NodeID.
+func resolveSelector(ctx context.Context, selector string) (cdp.NodeID, error) {
+ // Use Runtime.evaluate to get the remote object, then request the node.
+ expr := fmt.Sprintf(`document.querySelector(%q)`, selector)
+ val, _, err := runtime.Evaluate(expr).Do(ctx)
+ if err != nil {
+ return 0, fmt.Errorf("evaluate: %w", err)
+ }
+ if val.ObjectID == "" {
+ return 0, fmt.Errorf("no element matches selector")
+ }
+ node, err := dom.RequestNode(val.ObjectID).Do(ctx)
+ if err != nil {
+ return 0, fmt.Errorf("request node: %w", err)
+ }
+ return node, nil
+}
+
+// decodeFileData handles "data:mime;base64,..." and raw base64 strings.
+// Returns decoded bytes and a file extension guess.
+func decodeFileData(input string) ([]byte, string, error) {
+ ext := ""
+ var b64 string
+
+ if strings.HasPrefix(input, "data:") {
+ // data:image/png;base64,iVBOR...
+ parts := strings.SplitN(input, ",", 2)
+ if len(parts) != 2 {
+ return nil, "", fmt.Errorf("invalid data URL")
+ }
+ b64 = parts[1]
+ // Extract mime for extension.
+ meta := strings.TrimPrefix(parts[0], "data:")
+ mime := strings.SplitN(meta, ";", 2)[0]
+ ext = mimeToExt(mime)
+ } else {
+ b64 = input
+ }
+
+ data, err := base64.StdEncoding.DecodeString(b64)
+ if err != nil {
+ // Try URL-safe encoding.
+ data, err = base64.URLEncoding.DecodeString(b64)
+ if err != nil {
+ return nil, "", fmt.Errorf("base64 decode: %w", err)
+ }
+ }
+
+ if ext == "" {
+ ext = sniffExt(data)
+ }
+
+ return data, ext, nil
+}
+
+func mimeToExt(mime string) string {
+ switch mime {
+ case "image/png":
+ return ".png"
+ case "image/jpeg", "image/jpg":
+ return ".jpg"
+ case "image/gif":
+ return ".gif"
+ case "image/webp":
+ return ".webp"
+ case "image/svg+xml":
+ return ".svg"
+ case "application/pdf":
+ return ".pdf"
+ case "text/plain":
+ return ".txt"
+ case "text/csv":
+ return ".csv"
+ default:
+ return ".bin"
+ }
+}
+
+func sniffExt(data []byte) string {
+ if len(data) < 4 {
+ return ".bin"
+ }
+ switch {
+ case data[0] == 0x89 && data[1] == 'P' && data[2] == 'N' && data[3] == 'G':
+ return ".png"
+ case data[0] == 0xFF && data[1] == 0xD8:
+ return ".jpg"
+ case string(data[:3]) == "GIF":
+ return ".gif"
+ case string(data[:4]) == "RIFF" && len(data) > 11 && string(data[8:12]) == "WEBP":
+ return ".webp"
+ case data[0] == '%' && data[1] == 'P' && data[2] == 'D' && data[3] == 'F':
+ return ".pdf"
+ default:
+ return ".bin"
+ }
+}
diff --git a/internal/handlers/upload_test.go b/internal/handlers/upload_test.go
new file mode 100644
index 00000000..f5155232
--- /dev/null
+++ b/internal/handlers/upload_test.go
@@ -0,0 +1,88 @@
+package handlers
+
+import (
+ "testing"
+)
+
+func TestDecodeFileData_DataURL(t *testing.T) {
+ // 1x1 red PNG as data URL
+ input := "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg=="
+ data, ext, err := decodeFileData(input)
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if ext != ".png" {
+ t.Errorf("expected .png, got %s", ext)
+ }
+ if len(data) == 0 {
+ t.Error("expected non-empty data")
+ }
+ // Check PNG magic bytes
+ if data[0] != 0x89 || data[1] != 'P' {
+ t.Error("expected PNG magic bytes")
+ }
+}
+
+func TestDecodeFileData_RawBase64(t *testing.T) {
+ // 1x1 red PNG as raw base64
+ input := "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg=="
+ data, ext, err := decodeFileData(input)
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if ext != ".png" {
+ t.Errorf("expected .png (sniffed), got %s", ext)
+ }
+ if len(data) == 0 {
+ t.Error("expected non-empty data")
+ }
+}
+
+func TestDecodeFileData_InvalidBase64(t *testing.T) {
+ _, _, err := decodeFileData("not-valid-base64!!!")
+ if err == nil {
+ t.Error("expected error for invalid base64")
+ }
+}
+
+func TestMimeToExt(t *testing.T) {
+ tests := []struct {
+ mime string
+ ext string
+ }{
+ {"image/png", ".png"},
+ {"image/jpeg", ".jpg"},
+ {"image/gif", ".gif"},
+ {"image/webp", ".webp"},
+ {"application/pdf", ".pdf"},
+ {"text/plain", ".txt"},
+ {"application/octet-stream", ".bin"},
+ }
+ for _, tt := range tests {
+ if got := mimeToExt(tt.mime); got != tt.ext {
+ t.Errorf("mimeToExt(%q) = %q, want %q", tt.mime, got, tt.ext)
+ }
+ }
+}
+
+func TestSniffExt(t *testing.T) {
+ tests := []struct {
+ name string
+ data []byte
+ ext string
+ }{
+ {"png", []byte{0x89, 'P', 'N', 'G'}, ".png"},
+ {"jpg", []byte{0xFF, 0xD8, 0x00, 0x00}, ".jpg"},
+ {"gif", []byte("GIF89a"), ".gif"},
+ {"pdf", []byte("%PDF-1.4"), ".pdf"},
+ {"unknown", []byte{0x00, 0x01, 0x02, 0x03}, ".bin"},
+ {"short", []byte{0x00}, ".bin"},
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ if got := sniffExt(tt.data); got != tt.ext {
+ t.Errorf("sniffExt() = %q, want %q", got, tt.ext)
+ }
+ })
+ }
+}