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.goindex 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.goindex 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.gonew file mode 100644index 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.gonew file mode 100644index 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)+ }+ })+ }+}