strip ansi chars from paste & use opentui copy function first

jahooma · jahooma · commit 2ac662d8431f · 2026-03-16T00:20:31.000-07:00
diff --git a/cli/src/hooks/use-chat-keyboard.ts b/cli/src/hooks/use-chat-keyboard.ts
@@ -226,7 +226,8 @@ function dispatchAction(
       // Next, 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 text = readClipboardText()
+      const rawText = readClipboardText()
+      const text = rawText ? Bun.stripANSI(rawText) : null
       if (text) {
         // Check if the text is a path to an image file
         const imagePath = getImageFilePathFromText(text, cwd)
diff --git a/cli/src/hooks/use-clipboard.ts b/cli/src/hooks/use-clipboard.ts
@@ -4,7 +4,9 @@ import { useEffect, useRef, useState } from 'react'
 import { CURSOR_CHAR } from '../components/multiline-input'
 import {
   copyTextToClipboard,
+  registerClipboardRenderer,
   subscribeClipboardMessages,
+  unregisterClipboardRenderer,
 } from '../utils/clipboard'
 
 function formatDefaultClipboardMessage(text: string): string | null {
@@ -30,6 +32,18 @@ export const useClipboard = () => {
     return subscribeClipboardMessages(setStatusMessage)
   }, [])
 
+  // Register the renderer globally so all copyTextToClipboard callers
+  // can use the renderer's OSC 52 method when available.
+  useEffect(() => {
+    if (renderer) {
+      registerClipboardRenderer(renderer as unknown as Record<string, unknown>)
+      return () => {
+        unregisterClipboardRenderer()
+      }
+    }
+    return undefined
+  }, [renderer])
+
   useEffect(() => {
     const handleSelection = (selectionEvent: any) => {
       const selectionObj = selectionEvent ?? (renderer as any)?.getSelection?.()
diff --git a/cli/src/utils/__tests__/clipboard.test.ts b/cli/src/utils/__tests__/clipboard.test.ts
@@ -8,6 +8,8 @@ import {
   showClipboardMessage,
   subscribeClipboardMessages,
   clearClipboardMessage,
+  registerClipboardRenderer,
+  unregisterClipboardRenderer,
 } from '../clipboard'
 import { logger } from '../logger'
 
@@ -399,6 +401,139 @@ describe('clipboard', () => {
     })
   })
 
+  describe('registerClipboardRenderer and renderer-based copy', () => {
+    let originalPlatform: PropertyDescriptor | undefined
+    let originalEnv: Record<string, string | undefined>
+    let loggerErrorSpy: ReturnType<typeof spyOn>
+
+    beforeEach(() => {
+      originalPlatform = Object.getOwnPropertyDescriptor(process, 'platform')
+      originalEnv = {
+        SSH_CLIENT: process.env.SSH_CLIENT,
+        SSH_TTY: process.env.SSH_TTY,
+        SSH_CONNECTION: process.env.SSH_CONNECTION,
+        TERM: process.env.TERM,
+        TMUX: process.env.TMUX,
+        STY: process.env.STY,
+      }
+      loggerErrorSpy = spyOn(logger, 'error').mockImplementation(() => {})
+
+      // Use freebsd + dumb terminal to disable platform tools and OSC52,
+      // isolating the renderer path.
+      Object.defineProperty(process, 'platform', { value: 'freebsd', configurable: true })
+      delete process.env.SSH_CLIENT
+      delete process.env.SSH_TTY
+      delete process.env.SSH_CONNECTION
+      process.env.TERM = 'dumb'
+      delete process.env.TMUX
+      delete process.env.STY
+
+      clearClipboardMessage()
+      unregisterClipboardRenderer()
+    })
+
+    afterEach(() => {
+      unregisterClipboardRenderer()
+      if (originalPlatform) {
+        Object.defineProperty(process, 'platform', originalPlatform)
+      }
+      for (const [key, value] of Object.entries(originalEnv)) {
+        if (value !== undefined) process.env[key] = value
+        else delete process.env[key]
+      }
+      loggerErrorSpy.mockRestore()
+      clearClipboardMessage()
+    })
+
+    test('renderer with copyToClipboardOSC52 returning true succeeds', async () => {
+      const calls: string[] = []
+      registerClipboardRenderer({
+        copyToClipboardOSC52: (text: string) => {
+          calls.push(text)
+          return true
+        },
+      })
+
+      await copyTextToClipboard('test text', { suppressGlobalMessage: true })
+
+      expect(calls).toEqual(['test text'])
+    })
+
+    test('renderer with copyToClipboardOSC52 returning false falls through and fails', async () => {
+      registerClipboardRenderer({ copyToClipboardOSC52: () => false })
+
+      await expect(
+        copyTextToClipboard('test text', { suppressGlobalMessage: true })
+      ).rejects.toThrow('No clipboard method available')
+    })
+
+    test('renderer without copyToClipboardOSC52 falls through and fails', async () => {
+      registerClipboardRenderer({ someOtherMethod: () => true })
+
+      await expect(
+        copyTextToClipboard('test text', { suppressGlobalMessage: true })
+      ).rejects.toThrow('No clipboard method available')
+    })
+
+    test('renderer whose copyToClipboardOSC52 throws falls through gracefully', async () => {
+      registerClipboardRenderer({
+        copyToClipboardOSC52: () => { throw new Error('renderer error') },
+      })
+
+      await expect(
+        copyTextToClipboard('test text', { suppressGlobalMessage: true })
+      ).rejects.toThrow('No clipboard method available')
+    })
+
+    test('unregisterClipboardRenderer removes renderer so it is no longer used', async () => {
+      const calls: string[] = []
+      registerClipboardRenderer({
+        copyToClipboardOSC52: (text: string) => {
+          calls.push(text)
+          return true
+        },
+      })
+      unregisterClipboardRenderer()
+
+      await expect(
+        copyTextToClipboard('test text', { suppressGlobalMessage: true })
+      ).rejects.toThrow('No clipboard method available')
+
+      expect(calls).toEqual([])
+    })
+
+    test('renderer is tried in remote sessions (SSH) before manual OSC52', async () => {
+      // Set up as remote session
+      process.env.SSH_CLIENT = '192.168.1.100 54321 22'
+      process.env.TERM = 'xterm-256color'
+
+      const calls: string[] = []
+      registerClipboardRenderer({
+        copyToClipboardOSC52: () => {
+          calls.push('renderer')
+          return true
+        },
+      })
+
+      await copyTextToClipboard('test text', { suppressGlobalMessage: true })
+
+      expect(calls).toEqual(['renderer'])
+    })
+
+    test('shows success message when renderer copy succeeds', async () => {
+      registerClipboardRenderer({ copyToClipboardOSC52: () => true })
+
+      const messages: (string | null)[] = []
+      const unsubscribe = subscribeClipboardMessages((msg) => messages.push(msg))
+
+      await copyTextToClipboard('Hello world')
+
+      expect(messages).toContain('Copied: "Hello world"')
+
+      unsubscribe()
+    })
+  })
+
   describe('copyTextToClipboard - SSH session detection behavior', () => {
     // These tests verify the copy behavior changes based on SSH environment variables.
     // In remote sessions (SSH), OSC52 is tried first; in local sessions, platform tools are tried first.
diff --git a/cli/src/utils/__tests__/strings.test.ts b/cli/src/utils/__tests__/strings.test.ts
@@ -1,6 +1,14 @@
 import { describe, expect, test } from 'bun:test'
 
-import { truncateToLines, MAX_COLLAPSED_LINES } from '../strings'
+import {
+  truncateToLines,
+  MAX_COLLAPSED_LINES,
+  createTextPasteHandler,
+  createPasteHandler,
+  LONG_TEXT_THRESHOLD,
+} from '../strings'
+
+import type { InputValue } from '../../types/store'
 
 describe('MAX_COLLAPSED_LINES', () => {
   test('is set to 3', () => {
@@ -63,3 +71,122 @@ describe('truncateToLines', () => {
     expect(truncateToLines(text, 3)).toBe('line 1\nline 2\nline 3...')
   })
 })
+
+describe('createTextPasteHandler - ANSI stripping', () => {
+  test('strips ANSI escape sequences from pasted text', () => {
+    let result: InputValue | null = null
+    const handler = createTextPasteHandler('', 0, (value) => { result = value })
+
+    handler('\x1b[31mred text\x1b[0m')
+
+    expect(result).not.toBeNull()
+    expect(result!.text).toBe('red text')
+    expect(result!.cursorPosition).toBe(8)
+  })
+
+  test('passes through plain text unchanged', () => {
+    let result: InputValue | null = null
+    const handler = createTextPasteHandler('', 0, (value) => { result = value })
+
+    handler('plain text')
+
+    expect(result).not.toBeNull()
+    expect(result!.text).toBe('plain text')
+  })
+
+  test('strips complex ANSI sequences (bold, 256-color)', () => {
+    let result: InputValue | null = null
+    const handler = createTextPasteHandler('', 0, (value) => { result = value })
+
+    handler('\x1b[1m\x1b[38;5;196mbold colored\x1b[0m')
+
+    expect(result).not.toBeNull()
+    expect(result!.text).toBe('bold colored')
+  })
+
+  test('does not insert when text is only ANSI codes (empty after stripping)', () => {
+    let result: InputValue | null = null
+    const handler = createTextPasteHandler('', 0, (value) => { result = value })
+
+    handler('\x1b[31m\x1b[0m')
+
+    expect(result).toBeNull()
+  })
+
+  test('inserts stripped text at cursor position in existing text', () => {
+    let result: InputValue | null = null
+    const handler = createTextPasteHandler('hello world', 5, (value) => { result = value })
+
+    handler('\x1b[32m pasted\x1b[0m')
+
+    expect(result).not.toBeNull()
+    expect(result!.text).toBe('hello pasted world')
+    expect(result!.cursorPosition).toBe(12)
+  })
+})
+
+describe('createPasteHandler - ANSI stripping', () => {
+  test('strips ANSI from eventText for regular text paste', () => {
+    let result: InputValue | null = null
+    const handler = createPasteHandler({
+      text: '',
+      cursorPosition: 0,
+      onChange: (value) => { result = value },
+    })
+
+    handler('\x1b[31mhello\x1b[0m')
+
+    expect(result).not.toBeNull()
+    expect(result!.text).toBe('hello')
+    expect(result!.cursorPosition).toBe(5)
+  })
+
+  test('strips ANSI from eventText before checking long text threshold', () => {
+    let longTextResult: string | null = null
+    const handler = createPasteHandler({
+      text: '',
+      cursorPosition: 0,
+      onChange: () => {},
+      onPasteLongText: (text) => { longTextResult = text },
+    })
+
+    // Create text that is over threshold BEFORE stripping but under AFTER
+    const ansiOverhead = '\x1b[31m'.repeat(400) + '\x1b[0m'.repeat(400)
+    const shortContent = 'a'.repeat(100)
+    handler(ansiOverhead + shortContent)
+
+    // Should NOT be treated as long text since stripped content is short
+    expect(longTextResult).toBeNull()
+  })
+
+  test('strips ANSI but preserves plain text content', () => {
+    let result: InputValue | null = null
+    const handler = createPasteHandler({
+      text: 'existing ',
+      cursorPosition: 9,
+      onChange: (value) => { result = value },
+    })
+
+    handler('\x1b[1m\x1b[34mblue bold text\x1b[0m')
+
+    expect(result).not.toBeNull()
+    expect(result!.text).toBe('existing blue bold text')
+    expect(result!.cursorPosition).toBe(23)
+  })
+
+  test('long text handler receives stripped text', () => {
+    let longTextResult: string | null = null
+    const handler = createPasteHandler({
+      text: '',
+      cursorPosition: 0,
+      onChange: () => {},
+      onPasteLongText: (text) => { longTextResult = text },
+    })
+
+    const longContent = 'x'.repeat(LONG_TEXT_THRESHOLD + 1)
+    handler(`\x1b[31m${longContent}\x1b[0m`)
+
+    expect(longTextResult).not.toBeNull()
+    expect(longTextResult!).toBe(longContent)
+  })
+})
diff --git a/cli/src/utils/clipboard.ts b/cli/src/utils/clipboard.ts
@@ -4,6 +4,20 @@ import { createRequire } from 'module'
 import { getCliEnv } from './env'
 import { logger } from './logger'
 
+// Global renderer reference for clipboard operations.
+// Registered once by the useClipboard hook so all callers of
+// copyTextToClipboard automatically benefit from renderer-based
+// OSC 52 without threading the renderer through every call site.
+let registeredRenderer: Record<string, unknown> | null = null
+
+export function registerClipboardRenderer(renderer: Record<string, unknown>): void {
+  registeredRenderer = renderer
+}
+
+export function unregisterClipboardRenderer(): void {
+  registeredRenderer = null
+}
+
 const require = createRequire(import.meta.url)
 
 type ClipboardListener = (message: string | null) => void
@@ -85,11 +99,13 @@ export async function copyTextToClipboard(
   try {
     let copied: boolean
     if (isRemoteSession()) {
-      // Remote/SSH: prefer OSC 52 (copies to client terminal's clipboard)
-      copied = tryCopyViaOsc52(text) || tryCopyViaPlatformTool(text)
+      // Remote/SSH: prefer renderer OSC 52 (through render pipeline),
+      // then our manual OSC 52, then platform tools
+      copied = tryCopyViaRenderer(text) || tryCopyViaOsc52(text) || tryCopyViaPlatformTool(text)
     } else {
-      // Local: prefer platform tools (reliable with tmux), OSC 52 as fallback
-      copied = tryCopyViaPlatformTool(text) || tryCopyViaOsc52(text)
+      // Local: prefer platform tools (reliable with tmux),
+      // then renderer OSC 52, then our manual OSC 52 as fallback
+      copied = tryCopyViaPlatformTool(text) || tryCopyViaRenderer(text) || tryCopyViaOsc52(text)
     }
 
     if (!copied) {
@@ -161,6 +177,17 @@ function tryCopyViaPlatformTool(text: string): boolean {
   }
 }
 
+function tryCopyViaRenderer(text: string): boolean {
+  if (!registeredRenderer) return false
+  const copyFn = registeredRenderer.copyToClipboardOSC52
+  if (typeof copyFn !== 'function') return false
+  try {
+    return Boolean(copyFn.call(registeredRenderer, text))
+  } catch {
+    return false
+  }
+}
+
 // 32KB is safe for all environments (tmux is the strictest)
 const OSC52_MAX_PAYLOAD = 32_000
 
diff --git a/cli/src/utils/strings.ts b/cli/src/utils/strings.ts
