fix(ui): return clipboard paste to command input and keep log scroll

Address review feedback on #202:

- Ctrl+V in command mode never inserted text because bubbles returns
  the clipboard read as an unexported message type. Add clipboard.Paste,
  which reads the clipboard and re-enters as a public tea.PasteMsg, and
  intercept ctrl+v in CommandInput before delegating to the textinput.
- Mouse-wheel scrolling stopped working in LogView while the filter was
  active; mouse messages now bypass the filter fallback to the viewport.

Author: nick4eva

internal/app/app_test.go

@@ -526,6 +526,35 @@ func TestCommandModeActivation(t *testing.T) {
 	}
 }
 
+func TestCommandModePaste(t *testing.T) {
+	app := newTestApp(t)
+	app.currentView = &MockView{name: "Dashboard"}
+
+	app.Update(tea.KeyPressMsg{Code: 0, Text: ":"})
+	if !app.commandMode {
+		t.Fatal("Expected commandMode=true after ':' key")
+	}
+
+	// Ctrl+V is intercepted by the command input, which replies with the
+	// clipboard-read command instead of bubbles' unexported paste message.
+	_, cmd := app.Update(tea.KeyPressMsg{Code: 'v', Mod: tea.ModCtrl})
+	if cmd == nil {
+		t.Fatal("Expected ctrl+v in command mode to return the clipboard-read command")
+	}
+
+	// On success that command yields a tea.PasteMsg with the clipboard
+	// content (covered by internal/clipboard tests); feed the result back
+	// through App.Update and verify it reaches the command input.
+	app.Update(tea.PasteMsg{Content: "ec2/instances"})
+
+	if got := app.commandInput.Value(); got != "ec2/instances" {
+		t.Errorf("Command input value = %q, want %q", got, "ec2/instances")
+	}
+	if !app.commandMode {
+		t.Error("Expected command mode to stay active after paste")
+	}
+}
+
 func TestUnhandledKeyDelegatesToCurrentView(t *testing.T) {
 	app := newTestApp(t)
 	dashboard := &MockView{name: "Dashboard"}

internal/clipboard/clipboard.go

@@ -35,8 +35,26 @@ type CopyFailedMsg struct {
 var (
 	terminalClipboardWriter io.StringWriter = os.Stdout
 	nativeClipboardWrite                    = clipboard.WriteAll
+	nativeClipboardRead                     = clipboard.ReadAll
 )
 
+// Paste reads the system clipboard and delivers its content as a tea.PasteMsg,
+// the same message bracketed paste produces, so it can be routed to any focused
+// text input. Bubbles' built-in ctrl+v returns the clipboard read as an
+// unexported message type that message routing outside the input's own view
+// cannot forward; this command exists so callers get a public type instead.
+// The returned command is a no-op when the clipboard is unavailable.
+func Paste() tea.Cmd {
+	return func() tea.Msg {
+		value, err := nativeClipboardRead()
+		if err != nil {
+			log.Debug("native clipboard read failed", "error", err)
+			return nil
+		}
+		return tea.PasteMsg{Content: value}
+	}
+}
+
 // Copy copies the given value to the clipboard and returns a tea.Cmd that sends a CopiedMsg.
 // It writes to both OSC52 (terminal clipboard) and native system clipboard for maximum compatibility.
 func Copy(label, value string) tea.Cmd {

internal/clipboard/clipboard_test.go

@@ -4,8 +4,19 @@ import (
 	"errors"
 	"strings"
 	"testing"
+
+	tea "charm.land/bubbletea/v2"
 )
 
+func withClipboardReader(t *testing.T, nativeReader func() (string, error)) {
+	t.Helper()
+	originalNativeRead := nativeClipboardRead
+	nativeClipboardRead = nativeReader
+	t.Cleanup(func() {
+		nativeClipboardRead = originalNativeRead
+	})
+}
+
 type failingStringWriter struct{}
 
 func (failingStringWriter) WriteString(string) (int, error) {
@@ -130,6 +141,33 @@ func TestCopyARN(t *testing.T) {
 	}
 }
 
+func TestPasteReturnsPasteMsg(t *testing.T) {
+	withClipboardReader(t, func() (string, error) { return "i-1234567890abcdef0", nil })
+
+	cmd := Paste()
+	if cmd == nil {
+		t.Fatal("Paste should return a non-nil command")
+	}
+
+	msg := cmd()
+	pasteMsg, ok := msg.(tea.PasteMsg)
+	if !ok {
+		t.Fatalf("expected tea.PasteMsg, got %T", msg)
+	}
+	if pasteMsg.Content != "i-1234567890abcdef0" {
+		t.Errorf("expected Content 'i-1234567890abcdef0', got %q", pasteMsg.Content)
+	}
+}
+
+func TestPasteReturnsNilWhenClipboardUnavailable(t *testing.T) {
+	withClipboardReader(t, func() (string, error) { return "", errors.New("native clipboard unavailable") })
+
+	msg := Paste()()
+	if msg != nil {
+		t.Fatalf("expected nil msg when clipboard read fails, got %T", msg)
+	}
+}
+
 func TestNoARN(t *testing.T) {
 	cmd := NoARN()
 	if cmd == nil {

internal/view/command_input.go

@@ -11,6 +11,7 @@ import (
 	"charm.land/lipgloss/v2"
 
 	"github.com/clawscli/claws/internal/action"
+	"github.com/clawscli/claws/internal/clipboard"
 	"github.com/clawscli/claws/internal/config"
 	navmsg "github.com/clawscli/claws/internal/msg"
 	"github.com/clawscli/claws/internal/registry"
@@ -117,6 +118,11 @@ func (c *CommandInput) IsActive() bool {
 	return c.active
 }
 
+// Value returns the current input text.
+func (c *CommandInput) Value() string {
+	return c.textInput.Value()
+}
+
 // Update handles input updates
 func (c *CommandInput) Update(msg tea.Msg) (tea.Cmd, *NavigateMsg) {
 	switch msg := msg.(type) {
@@ -126,6 +132,13 @@ func (c *CommandInput) Update(msg tea.Msg) (tea.Cmd, *NavigateMsg) {
 			c.Deactivate()
 			return nil, nil
 
+		case "ctrl+v":
+			// Intercept before textInput.Update: its built-in paste replies
+			// with an unexported message type that command-mode routing in
+			// the app cannot forward back here. clipboard.Paste re-enters
+			// as a tea.PasteMsg, which routes to this input like any key.
+			return clipboard.Paste(), nil
+
 		case "enter":
 			cmd, nav := c.executeCommand()
 			c.Deactivate()

internal/view/log_view.go

@@ -383,7 +383,9 @@ func (v *LogView) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	}
 
 	// Route paste and other textinput-bound messages to the active filter.
-	if v.filterActive {
+	// Mouse events skip the filter so the viewport keeps scrolling while
+	// the filter is open.
+	if _, isMouse := msg.(tea.MouseMsg); v.filterActive && !isMouse {
 		return v.updateFilterInput(msg)
 	}
 

internal/view/log_view_test.go

@@ -507,6 +507,31 @@ func TestLogViewFilterStatusLine(t *testing.T) {
 	}
 }
 
+func TestLogViewMouseWheelScrollsWhileFiltering(t *testing.T) {
+	ctx := context.Background()
+	lv := NewLogView(ctx, "/aws/test")
+	lv.SetSize(80, 10)
+	lv.loading = false
+	for i := range 100 {
+		lv.logs = append(lv.logs, logEntry{timestamp: time.Now(), message: fmt.Sprintf("log line %d", i)})
+	}
+	lv.updateViewportContent()
+
+	lv.filterActive = true
+	lv.filterInput.Focus()
+
+	before := lv.vp.Model.YOffset()
+	lv.Update(tea.MouseWheelMsg{Button: tea.MouseWheelDown})
+	after := lv.vp.Model.YOffset()
+
+	if after <= before {
+		t.Errorf("Expected viewport to scroll down while filter is active, YOffset %d -> %d", before, after)
+	}
+	if lv.filterInput.Value() != "" {
+		t.Errorf("Expected filter input unchanged after mouse wheel, got %q", lv.filterInput.Value())
+	}
+}
+
 func TestLogViewFilterUnicode(t *testing.T) {
 	ctx := context.Background()
 	lv := NewLogView(ctx, "/aws/test")