clipboard: add cl copy --download option for images/videos

- offers application/vnd.portal.filetransfer and text/uri-list

core/internal/clipboard/clipboard.go

@@ -330,3 +330,163 @@ func selectPreferredMimeType(mimes []string) string {
 func IsImageMimeType(mime string) bool {
 	return len(mime) > 6 && mime[:6] == "image/"
 }
+
+type Offer struct {
+	MimeType string
+	Data     []byte
+}
+
+func CopyMulti(offers []Offer, foreground, pasteOnce bool) error {
+	if !foreground {
+		return copyMultiFork(offers, pasteOnce)
+	}
+	return copyMultiServe(offers, pasteOnce)
+}
+
+func copyMultiFork(offers []Offer, pasteOnce bool) error {
+	args := []string{os.Args[0], "cl", "copy", "--foreground", "--type", "__multi__"}
+	if pasteOnce {
+		args = append(args, "--paste-once")
+	}
+
+	cmd := exec.Command(args[0], args[1:]...)
+	cmd.Stdin = nil
+	cmd.Stdout = nil
+	cmd.Stderr = nil
+	cmd.SysProcAttr = &syscall.SysProcAttr{Setsid: true}
+
+	stdin, err := cmd.StdinPipe()
+	if err != nil {
+		return fmt.Errorf("stdin pipe: %w", err)
+	}
+
+	if err := cmd.Start(); err != nil {
+		return fmt.Errorf("start: %w", err)
+	}
+
+	for _, offer := range offers {
+		fmt.Fprintf(stdin, "%s\x00%d\x00", offer.MimeType, len(offer.Data))
+		if _, err := stdin.Write(offer.Data); err != nil {
+			stdin.Close()
+			return fmt.Errorf("write offer data: %w", err)
+		}
+	}
+	stdin.Close()
+
+	return nil
+}
+
+func copyMultiServe(offers []Offer, pasteOnce bool) error {
+	display, err := wlclient.Connect("")
+	if err != nil {
+		return fmt.Errorf("wayland connect: %w", err)
+	}
+	defer display.Destroy()
+
+	ctx := display.Context()
+	registry, err := display.GetRegistry()
+	if err != nil {
+		return fmt.Errorf("get registry: %w", err)
+	}
+	defer registry.Destroy()
+
+	var dataControlMgr *ext_data_control.ExtDataControlManagerV1
+	var seat *wlclient.Seat
+	var bindErr error
+
+	registry.SetGlobalHandler(func(e wlclient.RegistryGlobalEvent) {
+		switch e.Interface {
+		case "ext_data_control_manager_v1":
+			dataControlMgr = ext_data_control.NewExtDataControlManagerV1(ctx)
+			if err := registry.Bind(e.Name, e.Interface, e.Version, dataControlMgr); err != nil {
+				bindErr = err
+			}
+		case "wl_seat":
+			if seat != nil {
+				return
+			}
+			seat = wlclient.NewSeat(ctx)
+			if err := registry.Bind(e.Name, e.Interface, e.Version, seat); err != nil {
+				bindErr = err
+			}
+		}
+	})
+
+	display.Roundtrip()
+	display.Roundtrip()
+
+	if bindErr != nil {
+		return fmt.Errorf("registry bind: %w", bindErr)
+	}
+
+	if dataControlMgr == nil {
+		return fmt.Errorf("compositor does not support ext_data_control_manager_v1")
+	}
+	defer dataControlMgr.Destroy()
+
+	if seat == nil {
+		return fmt.Errorf("no seat available")
+	}
+
+	device, err := dataControlMgr.GetDataDevice(seat)
+	if err != nil {
+		return fmt.Errorf("get data device: %w", err)
+	}
+	defer device.Destroy()
+
+	source, err := dataControlMgr.CreateDataSource()
+	if err != nil {
+		return fmt.Errorf("create data source: %w", err)
+	}
+
+	offerMap := make(map[string][]byte)
+	for _, offer := range offers {
+		if err := source.Offer(offer.MimeType); err != nil {
+			return fmt.Errorf("offer %s: %w", offer.MimeType, err)
+		}
+		offerMap[offer.MimeType] = offer.Data
+	}
+
+	cancelled := make(chan struct{})
+	pasted := make(chan struct{}, 1)
+
+	source.SetSendHandler(func(e ext_data_control.ExtDataControlSourceV1SendEvent) {
+		defer syscall.Close(e.Fd)
+		file := os.NewFile(uintptr(e.Fd), "pipe")
+		defer file.Close()
+
+		if data, ok := offerMap[e.MimeType]; ok {
+			file.Write(data)
+		}
+
+		select {
+		case pasted <- struct{}{}:
+		default:
+		}
+	})
+
+	source.SetCancelledHandler(func(e ext_data_control.ExtDataControlSourceV1CancelledEvent) {
+		close(cancelled)
+	})
+
+	if err := device.SetSelection(source); err != nil {
+		return fmt.Errorf("set selection: %w", err)
+	}
+
+	display.Roundtrip()
+
+	for {
+		select {
+		case <-cancelled:
+			return nil
+		case <-pasted:
+			if pasteOnce {
+				return nil
+			}
+		default:
+			if err := ctx.Dispatch(); err != nil {
+				return nil
+			}
+		}
+	}
+}

core/internal/server/clipboard/manager.go

@@ -21,6 +21,7 @@ import (
 	"github.com/fsnotify/fsnotify"
 	_ "golang.org/x/image/bmp"
 	_ "golang.org/x/image/tiff"
+	_ "golang.org/x/image/webp"
 
 	bolt "go.etcd.io/bbolt"
 
@@ -316,6 +317,13 @@ func (m *Manager) readAndStore(r *os.File, mimeType string) {
 }
 
 func (m *Manager) storeClipboardEntry(data []byte, mimeType string) {
+	if mimeType == "text/uri-list" {
+		if imgData, imgMime, ok := m.tryReadImageFromURI(data); ok {
+			data = imgData
+			mimeType = imgMime
+		}
+	}
+
 	entry := Entry{
 		Data:      data,
 		MimeType:  mimeType,
@@ -327,6 +335,8 @@ func (m *Manager) storeClipboardEntry(data []byte, mimeType string) {
 	switch {
 	case entry.IsImage:
 		entry.Preview = m.imagePreview(data, mimeType)
+	case mimeType == "text/uri-list":
+		entry.Preview, entry.IsImage = m.uriListPreview(data)
 	default:
 		entry.Preview = m.textPreview(data)
 	}
@@ -507,6 +517,7 @@ func (m *Manager) hasSensitiveMimeType(mimes []string) bool {
 
 func (m *Manager) selectMimeType(mimes []string) string {
 	preferredTypes := []string{
+		"text/uri-list",
 		"text/plain;charset=utf-8",
 		"text/plain",
 		"UTF8_STRING",
@@ -557,6 +568,62 @@ func (m *Manager) imagePreview(data []byte, format string) string {
 	return fmt.Sprintf("[[ image %s %s %dx%d ]]", sizeStr(len(data)), imgFmt, config.Width, config.Height)
 }
 
+func (m *Manager) uriListPreview(data []byte) (string, bool) {
+	text := strings.TrimSpace(string(data))
+	uris := strings.Split(text, "\r\n")
+	if len(uris) == 0 {
+		uris = strings.Split(text, "\n")
+	}
+
+	if len(uris) == 1 && strings.HasPrefix(uris[0], "file://") {
+		filePath := strings.TrimPrefix(uris[0], "file://")
+		if info, err := os.Stat(filePath); err == nil && !info.IsDir() {
+			if imgData, err := os.ReadFile(filePath); err == nil {
+				if config, imgFmt, err := image.DecodeConfig(bytes.NewReader(imgData)); err == nil {
+					return fmt.Sprintf("[[ file %s %s %dx%d ]]", filepath.Base(filePath), imgFmt, config.Width, config.Height), true
+				}
+			}
+			return fmt.Sprintf("[[ file %s ]]", filepath.Base(filePath)), false
+		}
+	}
+
+	if len(uris) > 1 {
+		return fmt.Sprintf("[[ %d files ]]", len(uris)), false
+	}
+
+	return m.textPreview(data), false
+}
+
+func (m *Manager) tryReadImageFromURI(data []byte) ([]byte, string, bool) {
+	text := strings.TrimSpace(string(data))
+	uris := strings.Split(text, "\r\n")
+	if len(uris) == 0 {
+		uris = strings.Split(text, "\n")
+	}
+
+	if len(uris) != 1 || !strings.HasPrefix(uris[0], "file://") {
+		return nil, "", false
+	}
+
+	filePath := strings.TrimPrefix(uris[0], "file://")
+	info, err := os.Stat(filePath)
+	if err != nil || info.IsDir() {
+		return nil, "", false
+	}
+
+	imgData, err := os.ReadFile(filePath)
+	if err != nil {
+		return nil, "", false
+	}
+
+	_, imgFmt, err := image.DecodeConfig(bytes.NewReader(imgData))
+	if err != nil {
+		return nil, "", false
+	}
+
+	return imgData, "image/" + imgFmt, true
+}
+
 func sizeStr(size int) string {
 	units := []string{"B", "KiB", "MiB"}
 	var i int
@@ -1291,6 +1358,8 @@ func (m *Manager) StoreData(data []byte, mimeType string) error {
 	switch {
 	case entry.IsImage:
 		entry.Preview = m.imagePreview(data, mimeType)
+	case mimeType == "text/uri-list":
+		entry.Preview, entry.IsImage = m.uriListPreview(data)
 	default:
 		entry.Preview = m.textPreview(data)
 	}