feat: add paste support to InputHandler (#15)

* feat: add paste support to InputHandler

## Problem
Terminal had working copy (auto-copy on selection) but paste was
completely missing. Users couldn't paste text using Ctrl+V, Cmd+V,
or right-click paste.

## Solution
Added complete paste support to InputHandler:

1. **Paste Event Listener**: Listens for browser paste events on container
2. **handlePaste Method**: Extracts clipboard text and sends to terminal
3. **Ctrl+V/Cmd+V Support**: Bypasses normal keydown handling to allow paste
4. **Proper Cleanup**: Removes paste listener on dispose()

## Features
✅ Ctrl+V / Cmd+V keyboard shortcuts
✅ Right-click → Paste (browser context menu)
✅ Multi-line paste support
✅ Empty/null clipboard handling
✅ Focus-aware (only works when terminal focused)

## Tests
Added 6 comprehensive tests:
- Single-line paste
- Multi-line paste
- Empty clipboard handling
- Null clipboard data handling
- Ctrl+V shortcut behavior
- Cmd+V shortcut behavior

All 40 tests passing (6 new + 34 existing)

## Terminal Behavior Notes
- **Copy**: Auto-copy on mouse selection (no Ctrl+C copy)
- **Paste**: Ctrl+V / Cmd+V / Right-click
- **Ctrl+C**: Sends SIGINT (interrupt signal) - standard terminal behavior

This matches behavior of iTerm2, Terminal.app, Windows Terminal, etc.

## Files Changed
- lib/input-handler.ts: Added paste event handling
- lib/input-handler.test.ts: Added mock ClipboardEvent + 6 tests

## Future Enhancements
- Bracketed paste mode (\x1b[200~ ... \x1b[201~)
- Paste confirmation for large text blocks
- Rich text → plain text conversion
- Paste rate limiting

* fix: prevent Cmd+C from outputting 'c' character on Mac

## Problem
When pressing Cmd+C (Command+C on Mac) to copy selected text,
the terminal would output a 'c' character in addition to copying.
This happened because:
1. metaKey (Cmd) wasn't checked in isPrintableCharacter()
2. Cmd+C was being treated as a printable character
3. The 'c' was sent to the terminal output

## Solution
Two-part fix:

1. **Check metaKey in isPrintableCharacter()**
   - Added check: `if (event.metaKey) return false;`
   - Prevents ANY Cmd+key combo from being treated as printable

2. **Explicit Cmd+C handling**
   - Added early return for Cmd+C (similar to Cmd+V)
   - Allows SelectionManager to handle copy
   - Prevents any character from being sent to terminal

## Behavior
- **Ctrl+C**: Sends interrupt signal (0x03) - standard terminal
- **Cmd+C** (Mac): Triggers copy, no output - Mac standard
- **Selection**: Auto-copies on mouse selection (all platforms)
- **Cmd+V** (Mac): Triggers paste

This matches native Mac terminal behavior where:
- Cmd+C = Copy
- Cmd+V = Paste
- Ctrl+C = Interrupt (SIGINT)

## Tests
Added test: "Cmd+C allows copy (no data sent)"
- Verifies Cmd+C doesn't send any data to terminal
- All 41 tests passing

## Files Changed
- lib/input-handler.ts: Added metaKey check + Cmd+C handling
- lib/input-handler.test.ts: Added Cmd+C test

Fixes #issue (user reported Cmd+C outputting 'c')

Author: sreya

lib/input-handler.test.ts

@@ -20,9 +20,19 @@ interface MockKeyboardEvent {
   stopPropagation: () => void;
 }
 
+interface MockClipboardEvent {
+  type: string;
+  clipboardData: {
+    getData: (format: string) => string;
+    setData: (format: string, data: string) => void;
+  } | null;
+  preventDefault: () => void;
+  stopPropagation: () => void;
+}
+
 interface MockHTMLElement {
-  addEventListener: (event: string, handler: (e: MockKeyboardEvent) => void) => void;
-  removeEventListener: (event: string, handler: (e: MockKeyboardEvent) => void) => void;
+  addEventListener: (event: string, handler: (e: any) => void) => void;
+  removeEventListener: (event: string, handler: (e: any) => void) => void;
 }
 
 // Helper to create mock keyboard event
@@ -44,21 +54,42 @@ function createKeyEvent(
   };
 }
 
+// Helper to create mock clipboard event
+function createClipboardEvent(
+  text: string | null
+): MockClipboardEvent {
+  const data = new Map<string, string>();
+  if (text !== null) {
+    data.set('text/plain', text);
+  }
+  
+  return {
+    type: 'paste',
+    clipboardData: text !== null ? {
+      getData: (format: string) => data.get(format) || '',
+      setData: (format: string, value: string) => { data.set(format, value); },
+    } : null,
+    preventDefault: mock(() => {}),
+    stopPropagation: mock(() => {}),
+  };
+}
+
 // Helper to create mock container
 function createMockContainer(): MockHTMLElement & { 
-  _listeners: Map<string, ((e: MockKeyboardEvent) => void)[]> 
+  _listeners: Map<string, ((e: any) => void)[]>;
+  dispatchEvent: (event: any) => void;
 } {
-  const listeners = new Map<string, ((e: MockKeyboardEvent) => void)[]>();
+  const listeners = new Map<string, ((e: any) => void)[]>();
 
   return {
     _listeners: listeners,
-    addEventListener(event: string, handler: (e: MockKeyboardEvent) => void) {
+    addEventListener(event: string, handler: (e: any) => void) {
       if (!listeners.has(event)) {
         listeners.set(event, []);
       }
       listeners.get(event)!.push(handler);
     },
-    removeEventListener(event: string, handler: (e: MockKeyboardEvent) => void) {
+    removeEventListener(event: string, handler: (e: any) => void) {
       const handlers = listeners.get(event);
       if (handlers) {
         const index = handlers.indexOf(handler);
@@ -67,6 +98,12 @@ function createMockContainer(): MockHTMLElement & {
         }
       }
     },
+    dispatchEvent(event: any) {
+      const handlers = listeners.get(event.type) || [];
+      for (const handler of handlers) {
+        handler(event);
+      }
+    },
   };
 }
 
@@ -276,6 +313,21 @@ describe('InputHandler', () => {
       // Ctrl+Z should produce 0x1A (26)
       expect(dataReceived[0].charCodeAt(0)).toBe(0x1A);
     });
+
+    test('Cmd+C allows copy (no data sent)', () => {
+      const handler = new InputHandler(
+        ghostty,
+        container as any,
+        (data) => dataReceived.push(data),
+        () => { bellCalled = true; }
+      );
+
+      simulateKey(container, createKeyEvent('KeyC', 'c', { meta: true }));
+      
+      // Cmd+C should NOT send data - it should allow copy operation
+      // SelectionManager handles the actual copying
+      expect(dataReceived.length).toBe(0);
+    });
   });
 
   describe('Special Keys', () => {
@@ -610,4 +662,98 @@ describe('InputHandler', () => {
       expect(dataReceived[0].length).toBeGreaterThan(0);
     });
   });
+
+  describe('Clipboard Operations', () => {
+    test('handles paste event', () => {
+      const handler = new InputHandler(
+        ghostty,
+        container as any,
+        (data) => dataReceived.push(data),
+        () => { bellCalled = true; }
+      );
+
+      const pasteText = 'Hello, World!';
+      const pasteEvent = createClipboardEvent(pasteText);
+      
+      container.dispatchEvent(pasteEvent);
+      
+      expect(dataReceived.length).toBe(1);
+      expect(dataReceived[0]).toBe(pasteText);
+    });
+
+    test('handles multi-line paste', () => {
+      const handler = new InputHandler(
+        ghostty,
+        container as any,
+        (data) => dataReceived.push(data),
+        () => { bellCalled = true; }
+      );
+
+      const pasteText = 'Line 1\nLine 2\nLine 3';
+      const pasteEvent = createClipboardEvent(pasteText);
+      
+      container.dispatchEvent(pasteEvent);
+      
+      expect(dataReceived.length).toBe(1);
+      expect(dataReceived[0]).toBe(pasteText);
+    });
+
+    test('ignores paste with no clipboard data', () => {
+      const handler = new InputHandler(
+        ghostty,
+        container as any,
+        (data) => dataReceived.push(data),
+        () => { bellCalled = true; }
+      );
+
+      const pasteEvent = createClipboardEvent(null);
+      
+      container.dispatchEvent(pasteEvent);
+      
+      expect(dataReceived.length).toBe(0);
+    });
+
+    test('ignores paste with empty text', () => {
+      const handler = new InputHandler(
+        ghostty,
+        container as any,
+        (data) => dataReceived.push(data),
+        () => { bellCalled = true; }
+      );
+
+      const pasteEvent = createClipboardEvent('');
+      
+      container.dispatchEvent(pasteEvent);
+      
+      expect(dataReceived.length).toBe(0);
+    });
+
+    test('allows Ctrl+V to trigger paste', () => {
+      const handler = new InputHandler(
+        ghostty,
+        container as any,
+        (data) => dataReceived.push(data),
+        () => { bellCalled = true; }
+      );
+
+      // Ctrl+V should NOT call onData callback (lets paste event handle it)
+      simulateKey(container, createKeyEvent('KeyV', 'v', { ctrl: true }));
+      
+      expect(dataReceived.length).toBe(0);
+    });
+
+    test('allows Cmd+V to trigger paste', () => {
+      const handler = new InputHandler(
+        ghostty,
+        container as any,
+        (data) => dataReceived.push(data),
+        () => { bellCalled = true; }
+      );
+
+      // Cmd+V should NOT call onData callback (lets paste event handle it)
+      simulateKey(container, createKeyEvent('KeyV', 'v', { meta: true }));
+      
+      expect(dataReceived.length).toBe(0);
+    });
+  });
 });

lib/input-handler.ts

@@ -164,6 +164,7 @@ export class InputHandler {
   private onBellCallback: () => void;
   private keydownListener: ((e: KeyboardEvent) => void) | null = null;
   private keypressListener: ((e: KeyboardEvent) => void) | null = null;
+  private pasteListener: ((e: ClipboardEvent) => void) | null = null;
   private isDisposed = false;
 
   /**
@@ -207,6 +208,9 @@ export class InputHandler {
 
     this.keydownListener = this.handleKeyDown.bind(this);
     this.container.addEventListener('keydown', this.keydownListener);
+    
+    this.pasteListener = this.handlePaste.bind(this);
+    this.container.addEventListener('paste', this.pasteListener);
   }
 
   /**
@@ -244,10 +248,11 @@ export class InputHandler {
    * @returns true if printable character
    */
   private isPrintableCharacter(event: KeyboardEvent): boolean {
-    // If Ctrl or Alt is pressed (but not AltGr which is Ctrl+Alt on some keyboards)
-    // then it's not a simple printable character
+    // If Ctrl, Alt, or Meta (Cmd on Mac) is pressed, it's not a simple printable character
+    // Exception: AltGr (Ctrl+Alt on some keyboards) can produce printable characters
     if (event.ctrlKey && !event.altKey) return false;
     if (event.altKey && !event.ctrlKey) return false;
+    if (event.metaKey) return false; // Cmd key on Mac
 
     // If key produces a single printable character
     return event.key.length === 1;
@@ -260,6 +265,22 @@ export class InputHandler {
   private handleKeyDown(event: KeyboardEvent): void {
     if (this.isDisposed) return;
 
+    // Allow Ctrl+V and Cmd+V to trigger paste event (don't preventDefault)
+    if ((event.ctrlKey || event.metaKey) && event.code === 'KeyV') {
+      // Let the browser's native paste event fire
+      console.log('[InputHandler] ⌨️  Ctrl/Cmd+V detected, allowing paste event');
+      return;
+    }
+
+    // Allow Cmd+C for copy (on Mac, Cmd+C should copy, not send interrupt)
+    // SelectionManager handles the actual copying
+    // Note: Ctrl+C on all platforms sends interrupt signal (0x03)
+    if (event.metaKey && event.code === 'KeyC') {
+      // Let browser/SelectionManager handle copy
+      console.log('[InputHandler] ⌨️  Cmd+C detected, allowing copy');
+      return;
+    }
+
     // For printable characters without modifiers, send the character directly
     // This handles: a-z, A-Z (with shift), 0-9, punctuation, etc.
     if (this.isPrintableCharacter(event)) {
@@ -410,6 +431,39 @@ export class InputHandler {
     }
   }
 
+  /**
+   * Handle paste event from clipboard
+   * @param event - ClipboardEvent
+   */
+  private handlePaste(event: ClipboardEvent): void {
+    if (this.isDisposed) return;
+
+    // Prevent default paste behavior
+    event.preventDefault();
+    event.stopPropagation();
+
+    // Get clipboard data
+    const clipboardData = event.clipboardData;
+    if (!clipboardData) {
+      console.warn('No clipboard data available');
+      return;
+    }
+
+    // Get text from clipboard
+    const text = clipboardData.getData('text/plain');
+    if (!text) {
+      console.warn('No text in clipboard');
+      return;
+    }
+
+    console.log('[InputHandler] 📋 Pasting text:', text.substring(0, 50) + (text.length > 50 ? '...' : ''));
+
+    // Send the text to the terminal
+    // Note: For bracketed paste mode, we would wrap this in \x1b[200~ ... \x1b[201~
+    // but for now, send raw text
+    this.onDataCallback(text);
+  }
+
   /**
    * Dispose the InputHandler and remove event listeners
    */
@@ -426,6 +480,11 @@ export class InputHandler {
       this.keypressListener = null;
     }
 
+    if (this.pasteListener) {
+      this.container.removeEventListener('paste', this.pasteListener);
+      this.pasteListener = null;
+    }
+
     this.isDisposed = true;
   }