implement host-container clipboard bridge for images

Author: EstebanForge

.gitignore

@@ -36,5 +36,4 @@ build/
 # Test artifacts
 test-results/
 .test-cache/
-/.gemini-clipboard
-/reference-only-mcp-cli-ent
+/gemini-cli-main

internal/agent/runner.go

@@ -5,7 +5,9 @@ import (
 	"os"
 	"os/exec"
 	"strings"
+	stdruntime "runtime"
 
+	"github.com/EstebanForge/construct-cli/internal/clipboard"
 	"github.com/EstebanForge/construct-cli/internal/config"
 	"github.com/EstebanForge/construct-cli/internal/env"
 	"github.com/EstebanForge/construct-cli/internal/errors"
@@ -237,6 +239,20 @@ func runWithProviderEnv(args []string, cfg *config.Config, containerRuntime, con
 	osEnv := os.Environ()
 	osEnv = append(osEnv, "PWD="+cwd)
 
+	// Start Clipboard Server
+	cbServer, err := clipboard.StartServer()
+	if err != nil {
+		if ui.CurrentLogLevel >= ui.LogLevelInfo {
+			fmt.Printf("Warning: Failed to start clipboard server: %v\n", err)
+		}
+	} else {
+		if ui.CurrentLogLevel >= ui.LogLevelDebug {
+			fmt.Printf("Clipboard server running at %s\n", cbServer.URL)
+		}
+		osEnv = append(osEnv, "CONSTRUCT_CLIPBOARD_URL="+cbServer.URL)
+		osEnv = append(osEnv, "CONSTRUCT_CLIPBOARD_TOKEN="+cbServer.Token)
+	}
+
 	// Network configuration
 	osEnv = network.InjectEnv(osEnv, cfg)
 
@@ -271,6 +287,15 @@ func runWithProviderEnv(args []string, cfg *config.Config, containerRuntime, con
 	if containerRuntime == "docker" {
 		if _, err := exec.LookPath("docker-compose"); err == nil {
 			runArgs := append(composeArgs, "run", "--rm")
+			// Add host.docker.internal for Linux
+			if stdruntime.GOOS == "linux" {
+				runArgs = append(runArgs, "--add-host", "host.docker.internal:host-gateway")
+			}
+			// Inject clipboard env vars
+			if cbServer != nil {
+				runArgs = append(runArgs, "-e", "CONSTRUCT_CLIPBOARD_URL="+cbServer.URL)
+				runArgs = append(runArgs, "-e", "CONSTRUCT_CLIPBOARD_TOKEN="+cbServer.Token)
+			}
 			// Inject provider env vars
 			for _, envVar := range providerEnv {
 				runArgs = append(runArgs, "-e", envVar)
@@ -282,6 +307,15 @@ func runWithProviderEnv(args []string, cfg *config.Config, containerRuntime, con
 			runArgs := []string{"compose"}
 			runArgs = append(runArgs, composeArgs...)
 			runArgs = append(runArgs, "run", "--rm")
+			// Add host.docker.internal for Linux
+			if stdruntime.GOOS == "linux" {
+				runArgs = append(runArgs, "--add-host", "host.docker.internal:host-gateway")
+			}
+			// Inject clipboard env vars
+			if cbServer != nil {
+				runArgs = append(runArgs, "-e", "CONSTRUCT_CLIPBOARD_URL="+cbServer.URL)
+				runArgs = append(runArgs, "-e", "CONSTRUCT_CLIPBOARD_TOKEN="+cbServer.Token)
+			}
 			// Inject provider env vars
 			for _, envVar := range providerEnv {
 				runArgs = append(runArgs, "-e", envVar)
@@ -292,6 +326,15 @@ func runWithProviderEnv(args []string, cfg *config.Config, containerRuntime, con
 		}
 	} else if containerRuntime == "podman" {
 		runArgs := append(composeArgs, "run", "--rm")
+		// Add host.docker.internal for Linux
+		if stdruntime.GOOS == "linux" {
+			runArgs = append(runArgs, "--add-host", "host.docker.internal:host-gateway")
+		}
+		// Inject clipboard env vars
+		if cbServer != nil {
+			runArgs = append(runArgs, "-e", "CONSTRUCT_CLIPBOARD_URL="+cbServer.URL)
+			runArgs = append(runArgs, "-e", "CONSTRUCT_CLIPBOARD_TOKEN="+cbServer.Token)
+		}
 		// Inject provider env vars
 		for _, envVar := range providerEnv {
 			runArgs = append(runArgs, "-e", envVar)
@@ -303,6 +346,15 @@ func runWithProviderEnv(args []string, cfg *config.Config, containerRuntime, con
 		runArgs := []string{"compose"}
 		runArgs = append(runArgs, composeArgs...)
 		runArgs = append(runArgs, "run", "--rm")
+		// Add host.docker.internal for Linux
+		if stdruntime.GOOS == "linux" {
+			runArgs = append(runArgs, "--add-host", "host.docker.internal:host-gateway")
+		}
+		// Inject clipboard env vars
+		if cbServer != nil {
+			runArgs = append(runArgs, "-e", "CONSTRUCT_CLIPBOARD_URL="+cbServer.URL)
+			runArgs = append(runArgs, "-e", "CONSTRUCT_CLIPBOARD_TOKEN="+cbServer.Token)
+		}
 		// Inject provider env vars
 		for _, envVar := range providerEnv {
 			runArgs = append(runArgs, "-e", envVar)

internal/clipboard/clipboard.go

@@ -0,0 +1,177 @@
+package clipboard
+
+import (
+	"bytes"
+	"encoding/base64"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"runtime"
+)
+
+var ErrNoImage = errors.New("no image in clipboard")
+var ErrNoText = errors.New("no text in clipboard")
+
+// GetText retrieves text data from the host clipboard
+func GetText() ([]byte, error) {
+	switch runtime.GOOS {
+	case "darwin":
+		return getMacText()
+	case "linux":
+		return getLinuxText()
+	case "windows":
+		return getWindowsText()
+	default:
+		return nil, fmt.Errorf("unsupported OS: %s", runtime.GOOS)
+	}
+}
+
+// GetImage retrieves PNG data from the host clipboard using OS-specific tools
+func GetImage() ([]byte, error) {
+	switch runtime.GOOS {
+	case "darwin":
+		return getMacImage()
+	case "linux":
+		return getLinuxImage()
+	case "windows":
+		return getWindowsImage()
+	default:
+		return nil, fmt.Errorf("unsupported OS: %s", runtime.GOOS)
+	}
+}
+
+func getMacImage() ([]byte, error) {
+	// Request clipboard as PNG data. osascript will return it as a hex string
+	// in the format: «data PNGf89504E47...»
+	script := "get the clipboard as «class PNGf»"
+	cmd := exec.Command("osascript", "-e", script)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		// If it fails, maybe no image
+		return nil, ErrNoImage
+	}
+
+	trimmed := bytes.TrimSpace(output)
+	if len(trimmed) == 0 {
+		return nil, ErrNoImage
+	}
+
+	// Look for the hex start. PNG magic is 89504E47.
+	// The output is usually «data PNGf89504E47...»
+	startMarker := []byte("«data PNGf")
+	endMarker := []byte("»")
+	
+	startIdx := bytes.Index(trimmed, startMarker)
+	if startIdx == -1 {
+		return nil, ErrNoImage
+	}
+	startIdx += len(startMarker)
+	
+	endIdx := bytes.LastIndex(trimmed, endMarker)
+	if endIdx == -1 {
+		endIdx = len(trimmed)
+	}
+
+	hexData := trimmed[startIdx:endIdx]
+	
+	// Decode hex
+	data := make([]byte, hex.DecodedLen(len(hexData)))
+	n, err := hex.Decode(data, hexData)
+	if err != nil {
+		return nil, fmt.Errorf("failed to decode clipboard hex data: %w", err)
+	}
+
+	return data[:n], nil
+}
+
+func getLinuxImage() ([]byte, error) {
+	// Try wl-paste (Wayland) first, then xclip (X11)
+	
+	// Check if we are in Wayland
+	if os.Getenv("WAYLAND_DISPLAY") != "" {
+		cmd := exec.Command("wl-paste", "-t", "image/png")
+		data, err := cmd.Output()
+		if err == nil && len(data) > 0 {
+			return data, nil
+		}
+		// Fallthrough to xclip if wl-paste fails or not present
+	}
+
+	// Try xclip
+	cmd := exec.Command("xclip", "-selection", "clipboard", "-t", "image/png", "-o")
+	data, err := cmd.Output()
+	if err != nil {
+		// Verify if xclip is installed
+		if _, lookErr := exec.LookPath("xclip"); lookErr != nil {
+			return nil, fmt.Errorf("xclip or wl-paste not found on host")
+		}
+		// xclip returns error if no target found (no image)
+		return nil, ErrNoImage
+	}
+
+	if len(data) == 0 {
+		return nil, ErrNoImage
+	}
+
+	return data, nil
+}
+
+func getMacText() ([]byte, error) {
+	cmd := exec.Command("pbpaste")
+	return cmd.Output()
+}
+
+func getLinuxText() ([]byte, error) {
+	// Try wl-paste
+	if os.Getenv("WAYLAND_DISPLAY") != "" {
+		cmd := exec.Command("wl-paste", "--no-newline")
+		data, err := cmd.Output()
+		if err == nil {
+			return data, nil
+		}
+	}
+	// Try xclip
+	cmd := exec.Command("xclip", "-selection", "clipboard", "-o")
+	return cmd.Output()
+}
+
+func getWindowsText() ([]byte, error) {
+	cmd := exec.Command("powershell", "-NoProfile", "-Command", "Get-Clipboard -Raw")
+	return cmd.Output()
+}
+
+func getWindowsImage() ([]byte, error) {
+	// Use PowerShell to get clipboard image
+	// We use a script to output base64 then decode
+	
+	psScript := `
+		Add-Type -AssemblyName System.Windows.Forms
+		$img = [System.Windows.Forms.Clipboard]::GetImage()
+		if ($img -eq $null) { exit 1 }
+		$ms = New-Object System.IO.MemoryStream
+		$img.Save($ms, [System.Drawing.Imaging.ImageFormat]::Png)
+		$base64 = [Convert]::ToBase64String($ms.ToArray())
+		Write-Output $base64
+	`
+	
+	// Note: System.Windows.Forms requires STA mode (-Sta)
+	cmd := exec.Command("powershell", "-NoProfile", "-Sta", "-Command", psScript)
+	output, err := cmd.Output()
+	if err != nil {
+		return nil, ErrNoImage // Assume no image or failure
+	}
+
+	base64Str := string(bytes.TrimSpace(output))
+	if base64Str == "" {
+		return nil, ErrNoImage
+	}
+
+	data, err := base64.StdEncoding.DecodeString(base64Str)
+	if err != nil {
+		return nil, fmt.Errorf("failed to decode base64 image data: %w", err)
+	}
+	
+	return data, nil
+}

internal/clipboard/server.go

@@ -0,0 +1,103 @@
+package clipboard
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"fmt"
+	"net"
+	"net/http"
+	"os"
+)
+
+// Server represents the clipboard server
+type Server struct {
+	Port  int
+	Token string
+	URL   string
+	listener net.Listener
+}
+
+// StartServer starts the clipboard server on a random port
+func StartServer() (*Server, error) {
+	// Generate random token
+
+tokenBytes := make([]byte, 32)
+	if _, err := rand.Read(tokenBytes); err != nil {
+		return nil, fmt.Errorf("failed to generate token: %w", err)
+	}
+token := hex.EncodeToString(tokenBytes)
+
+	// Listen on random port (all interfaces to allow container access)
+	listener, err := net.Listen("tcp", "0.0.0.0:0")
+	if err != nil {
+		return nil, fmt.Errorf("failed to start listener: %w", err)
+	}
+
+	port := listener.Addr().(*net.TCPAddr).Port
+	
+	// Determine URL host (host.docker.internal is standard, but we return the port)
+	// The client inside container will use host.docker.internal
+	url := fmt.Sprintf("http://host.docker.internal:%d", port)
+
+	server := &Server{
+		Port:     port,
+		Token:    token,
+		URL:      url,
+		listener: listener,
+	}
+
+	// Start serving in background
+	go server.serve()
+
+	return server, nil
+}
+
+func (s *Server) serve() {
+	mux := http.NewServeMux()
+	mux.HandleFunc("/paste", s.handlePaste)
+
+	// We use the existing listener
+	http.Serve(s.listener, mux)
+}
+
+func (s *Server) handlePaste(w http.ResponseWriter, r *http.Request) {
+	fmt.Fprintf(os.Stderr, "[Clipboard Server] Received paste request from %s\n", r.RemoteAddr)
+	
+	// Verify token
+	if r.Header.Get("X-Construct-Clip-Token") != s.Token {
+		fmt.Fprintf(os.Stderr, "[Clipboard Server] Unauthorized request (invalid token)\n")
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	contentType := r.URL.Query().Get("type")
+	
+	if contentType == "text/plain" || contentType == "" {
+		data, err := GetText()
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "[Clipboard Server] GetText error: %v\n", err)
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		fmt.Fprintf(os.Stderr, "[Clipboard Server] Serving %d bytes of text data\n", len(data))
+		w.Header().Set("Content-Type", "text/plain")
+		w.Write(data)
+		return
+	}
+
+	// Get image from host clipboard
+	data, err := GetImage()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "[Clipboard Server] GetImage error: %v\n", err)
+		if err == ErrNoImage {
+			http.Error(w, "No image in clipboard", http.StatusNotFound)
+		} else {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+		}
+		return
+	}
+
+	fmt.Fprintf(os.Stderr, "[Clipboard Server] Serving %d bytes of image data\n", len(data))
+	w.Header().Set("Content-Type", "image/png")
+	w.Write(data)
+}