fix(chat): don't attach a selection chip to a copy from a nested input

Cursor Bugbot: a copy from a field inside the editor — Monaco's find box being
the common one — bubbles to the container while the document still holds a
highlight, so the bridge attached the editor selection to text the user never
copied. Chat paste then prefers the custom MIME and inserts a reference chip
instead of the search term.

Skips INPUT targets only. Copying the table grid's INPUT/TEXTAREA guard would
have suppressed the chip on the main copy path this hook exists for: Monaco's
own editing surface is a hidden textarea, unlike the grid's cell editors, which
really are form fields.

Tests cover both directions — chip attached from the textarea surface, skipped
from a nested input — and were verified to fail against the missing guard and
against the INPUT+TEXTAREA variant.

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/use-selection-copy-bridge.test.tsx

@@ -0,0 +1,88 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { act, createRef, type RefObject } from 'react'
+import { createRoot, type Root } from 'react-dom/client'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { SIM_SELECTION_MIME } from '@/lib/copilot/chat/selection-clipboard'
+import type { ChatContext } from '@/stores/panel'
+import { useSelectionCopyBridge } from './use-selection-copy-bridge'
+
+const selection: ChatContext = {
+  kind: 'file_selection',
+  fileId: 'f1',
+  fileName: 'notes.md',
+  label: 'notes.md:2-4',
+  text: 'the exact passage',
+}
+
+let container: HTMLDivElement
+let root: Root
+let containerRef: RefObject<HTMLDivElement | null>
+let buildContext: ReturnType<typeof vi.fn>
+
+/**
+ * Mirrors the editors this hook wraps: Monaco's editing surface is a hidden
+ * textarea, and its find widget is a real input nested in the same container.
+ */
+function Host() {
+  useSelectionCopyBridge(containerRef, buildContext as () => ChatContext | null)
+  return (
+    <div ref={containerRef}>
+      <textarea id='editor-surface' />
+      <input id='find-box' />
+    </div>
+  )
+}
+
+/** Dispatches a bubbling copy from `id` and returns what was written. */
+function dispatchCopy(id: string): Record<string, string> {
+  const written: Record<string, string> = {}
+  const event = new Event('copy', { bubbles: true }) as ClipboardEvent
+  Object.defineProperty(event, 'clipboardData', {
+    value: {
+      setData: (type: string, value: string) => {
+        written[type] = value
+      },
+    },
+  })
+  act(() => {
+    container.querySelector(`#${id}`)?.dispatchEvent(event)
+  })
+  return written
+}
+
+describe('useSelectionCopyBridge', () => {
+  beforeEach(() => {
+    container = document.createElement('div')
+    document.body.appendChild(container)
+    containerRef = createRef<HTMLDivElement>()
+    buildContext = vi.fn(() => selection)
+    root = createRoot(container)
+    act(() => {
+      root.render(<Host />)
+    })
+  })
+
+  afterEach(() => {
+    act(() => root.unmount())
+    container.remove()
+    vi.clearAllMocks()
+  })
+
+  it('attaches the selection when copying from the editor surface', () => {
+    const written = dispatchCopy('editor-surface')
+
+    expect(buildContext).toHaveBeenCalled()
+    expect(written[SIM_SELECTION_MIME]).toContain('file_selection')
+  })
+
+  it('ignores a copy from a nested input such as the find box', () => {
+    // The document still holds a highlight, so without the guard the chip would
+    // ride onto text the user never copied.
+    const written = dispatchCopy('find-box')
+
+    expect(buildContext).not.toHaveBeenCalled()
+    expect(written[SIM_SELECTION_MIME]).toBeUndefined()
+  })
+})

apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/use-selection-copy-bridge.ts

@@ -26,6 +26,15 @@ export function useSelectionCopyBridge(
     const dom = containerRef.current
     if (!dom || !enabled) return
     const onCopy = (e: ClipboardEvent) => {
+      // A copy from a field nested in the editor — Monaco's find box being the
+      // common one — bubbles here while the document still holds a highlight,
+      // so the selection would be attached to text the user never copied.
+      //
+      // Only INPUT is skipped, deliberately: Monaco's own editing surface is a
+      // hidden TEXTAREA, so excluding textareas (as the table grid does, where
+      // the cell editors really are form fields) would suppress the chip on the
+      // main copy path this hook exists for.
+      if ((e.target as HTMLElement | null)?.tagName === 'INPUT') return
       const context = buildContext()
       if (context) attachSelectionContextToClipboard(e.clipboardData, context)
     }