feat(cli): add support for pasting/dragging image file paths

- Add onPasteImagePath handler for image file paths
- Check clipboard text for file paths before checking for image data
- Ensure consistent priority: file paths > clipboard images > text
- Add Windows line ending support in path detection
- Use consistent cwd resolution (getProjectRoot)

Author: brandonkachen

cli/src/chat.tsx

@@ -45,7 +45,7 @@ import { useUsageMonitor } from './hooks/use-usage-monitor'
 import { getProjectRoot } from './project-files'
 import { useChatStore } from './state/chat-store'
 import { useFeedbackStore } from './state/feedback-store'
-import { addClipboardPlaceholder, addPendingImageFromFile } from './utils/add-pending-image'
+import { addClipboardPlaceholder, addPendingImageFromFile, validateAndAddImage } from './utils/add-pending-image'
 import { createChatScrollAcceleration } from './utils/chat-scroll-accel'
 import { showClipboardMessage } from './utils/clipboard'
 import { readClipboardImage } from './utils/clipboard-image'
@@ -979,6 +979,10 @@ export const Chat = ({
           void addPendingImageFromFile(result.imagePath, cwd, placeholderPath)
         }, 0)
       },
+      onPasteImagePath: (imagePath: string) => {
+        const cwd = getProjectRoot() ?? process.cwd()
+        void validateAndAddImage(imagePath, cwd)
+      },
       onPasteText: (text: string) => {
         setInputValue((prev) => {
           const before = prev.text.slice(0, prev.cursorPosition)
@@ -1240,6 +1244,8 @@ export const Chat = ({
             cursorPosition,
             onChange: setInputValue,
             onPasteImage: chatKeyboardHandlers.onPasteImage,
+            onPasteImagePath: chatKeyboardHandlers.onPasteImagePath,
+            cwd: getProjectRoot() ?? process.cwd(),
           })}
         />
       </box>

cli/src/hooks/use-chat-keyboard.ts

@@ -1,7 +1,8 @@
 import { useKeyboard } from '@opentui/react'
 import { useCallback } from 'react'
 
-import { hasClipboardImage, readClipboardText } from '../utils/clipboard-image'
+import { hasClipboardImage, readClipboardText, getImageFilePathFromText } from '../utils/clipboard-image'
+import { getProjectRoot } from '../project-files'
 import {
   resolveChatKeyboardAction,
   type ChatKeyboardState,
@@ -66,6 +67,7 @@ export type ChatKeyboardHandlers = {
 
   // Clipboard handlers
   onPasteImage: () => void
+  onPasteImagePath: (imagePath: string) => void
   onPasteText: (text: string) => void
 }
 
@@ -171,14 +173,28 @@ function dispatchAction(
       handlers.onBashHistoryDown()
       return true
     case 'paste': {
-      // Check for image FIRST - many apps put both text and image on clipboard
-      // when copying an image (e.g., Chrome, Slack, Finder), so we prioritize image
+      // First, read clipboard text to check if it's a file path
+      // This handles the case where a file is dragged/dropped - we want to use
+      // the file path, not any stale image data that might be in the clipboard
+      const cwd = getProjectRoot() ?? process.cwd()
+      const text = readClipboardText()
+      if (text) {
+        // Check if the text is a path to an image file
+        const imagePath = getImageFilePathFromText(text, cwd)
+        if (imagePath) {
+          handlers.onPasteImagePath(imagePath)
+          return true
+        }
+      }
+      
+      // Check for actual image data in clipboard (screenshots, copied images)
+      // This comes AFTER the file path check so dragged files take priority
       if (hasClipboardImage()) {
         handlers.onPasteImage()
         return true
       }
-      // No image - try text
-      const text = readClipboardText()
+      
+      // Regular text paste
       if (text) {
         handlers.onPasteText(text)
         return true

cli/src/utils/clipboard-image.ts

@@ -3,6 +3,8 @@ import { existsSync, mkdirSync, writeFileSync } from 'fs'
 import os from 'os'
 import path from 'path'
 
+import { isImageFile, resolveFilePath } from './image-handler'
+
 export interface ClipboardImageResult {
   success: boolean
   imagePath?: string
@@ -31,7 +33,12 @@ function generateImageFilename(): string {
 
 /**
  * Check if clipboard contains an image (macOS)
- * Uses 'clipboard info' which is the fastest way to check clipboard types
+ * Uses 'clipboard info' which is the fastest way to check clipboard types.
+ * 
+ * Note: We do NOT filter out clipboards that contain file URLs here, because
+ * copying images from Finder/Preview/Safari often includes both a file URL
+ * AND the actual image data. The caller handles priority (file paths are
+ * checked first via clipboard text, then we fall back to image data).
  */
 function hasImageMacOS(): boolean {
   try {
@@ -45,6 +52,7 @@ function hasImageMacOS(): boolean {
     }
 
     const output = result.stdout || ''
+    
     // Check for image types in clipboard info
     return output.includes('«class PNGf»') || 
            output.includes('TIFF') || 
@@ -302,6 +310,49 @@ export function readClipboardImage(): ClipboardImageResult {
   }
 }
 
+/**
+ * Check if text looks like a single file path pointing to an existing image.
+ * Used to detect drag-drop of image files into the terminal.
+ * Returns the resolved absolute path if valid, null otherwise.
+ */
+export function getImageFilePathFromText(text: string, cwd: string): string | null {
+  // Must be single line (no internal newlines, including Windows \r\n)
+  if (text.includes('\n') || text.includes('\r')) return null
+  
+  // Must not be empty or have only whitespace
+  let trimmed = text.trim()
+  if (!trimmed) return null
+  
+  // Handle file:// URLs that some systems use for dragged files
+  if (trimmed.startsWith('file://')) {
+    trimmed = decodeURIComponent(trimmed.slice(7))
+  }
+  
+  // Skip if it looks like a URL (but not file:// which we already handled)
+  if (trimmed.includes('://')) return null
+  
+  // Remove surrounding quotes that some terminals add
+  if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+      (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+    trimmed = trimmed.slice(1, -1)
+  }
+  
+  try {
+    // Try to resolve the path
+    const resolvedPath = resolveFilePath(trimmed, cwd)
+    
+    // Check if file exists
+    if (!existsSync(resolvedPath)) return null
+    
+    // Check if it's a supported image format
+    if (!isImageFile(resolvedPath)) return null
+    
+    return resolvedPath
+  } catch {
+    return null
+  }
+}
+
 /**
  * Read text from clipboard. Returns null if reading fails.
  */

cli/src/utils/strings.ts

@@ -1,4 +1,4 @@
-import { hasClipboardImage, readClipboardText } from './clipboard-image'
+import { hasClipboardImage, readClipboardText, getImageFilePathFromText } from './clipboard-image'
 import type { InputValue } from '../state/chat-store'
 
 export function getSubsequenceIndices(
@@ -62,26 +62,65 @@ export function createTextPasteHandler(
 
 /**
  * Creates a paste handler that supports both image and text paste.
- * Checks for image first, falls back to text paste.
+ * 
+ * When fallbackText is provided (from drag-drop or native paste event),
+ * it takes FULL priority over the clipboard. This is because:
+ * - Drag operations provide file paths directly without updating the clipboard
+ * - The clipboard might contain stale data from a previous copy operation
+ * 
+ * Only when NO fallbackText is provided do we read from the clipboard.
  */
 export function createPasteHandler(options: {
   text: string
   cursorPosition: number
   onChange: (value: InputValue) => void
   onPasteImage?: () => void
+  onPasteImagePath?: (imagePath: string) => void
+  cwd?: string
 }): (fallbackText?: string) => void {
-  const { text, cursorPosition, onChange, onPasteImage } = options
+  const { text, cursorPosition, onChange, onPasteImage, onPasteImagePath, cwd } = options
   return (fallbackText) => {
-    // Check for image first if handler provided
+    // If we have direct input text from the paste event (e.g., from drag-drop),
+    // use it exclusively and ignore the clipboard entirely.
+    // Drag operations don't update the clipboard, so clipboard data would be stale.
+    if (fallbackText) {
+      // Check if it's a path to an image file
+      if (onPasteImagePath && cwd) {
+        const imagePath = getImageFilePathFromText(fallbackText, cwd)
+        if (imagePath) {
+          onPasteImagePath(imagePath)
+          return
+        }
+      }
+      
+      // Not an image path, insert as regular text
+      const { newText, newCursor } = insertTextAtCursor(text, cursorPosition, fallbackText)
+      onChange({ text: newText, cursorPosition: newCursor, lastEditDueToNav: false })
+      return
+    }
+    
+    // No direct text provided - read from clipboard
+    const pasteText = readClipboardText()
+    
+    // First check if clipboard text is a path to an image file
+    // File paths take priority over clipboard image data
+    if (pasteText && onPasteImagePath && cwd) {
+      const imagePath = getImageFilePathFromText(pasteText, cwd)
+      if (imagePath) {
+        onPasteImagePath(imagePath)
+        return
+      }
+    }
+    
+    // Check for actual image data (screenshots, copied images)
     if (onPasteImage && hasClipboardImage()) {
       onPasteImage()
       return
     }
-    // Handle text paste
-    const pasteText = readClipboardText() ?? fallbackText
-    if (pasteText) {
-      const { newText, newCursor } = insertTextAtCursor(text, cursorPosition, pasteText)
-      onChange({ text: newText, cursorPosition: newCursor, lastEditDueToNav: false })
-    }
+    
+    // Regular text paste
+    if (!pasteText) return
+    const { newText, newCursor } = insertTextAtCursor(text, cursorPosition, pasteText)
+    onChange({ text: newText, cursorPosition: newCursor, lastEditDueToNav: false })
   }
-}
+}