fix(ui): keep paste limits as safety hatches

Author: waleedlatif1

apps/realtime/src/config/socket.ts

@@ -11,8 +11,11 @@ const logger = createLogger('SocketIOConfig')
 const PING_TIMEOUT_MS = 60000
 /** Socket.IO ping interval - how often to send ping packets */
 const PING_INTERVAL_MS = 25000
-/** Maximum HTTP buffer size for Socket.IO messages */
-const MAX_HTTP_BUFFER_SIZE = 1e6
+/**
+ * Accommodates the existing 5 MiB collaborative-document boundary plus Yjs and Socket.IO framing.
+ * This remains a transport safety hatch, not a product-sized text limit.
+ */
+const MAX_HTTP_BUFFER_SIZE = 8 * 1024 * 1024
 
 let adapterPubClient: RedisClientType | null = null
 let adapterSubClient: RedisClientType | null = null

apps/sim/app/_shell/paste-admission-guard.test.tsx

@@ -53,17 +53,14 @@ describe('PasteAdmissionGuard', () => {
     expect(warning).toHaveBeenCalledOnce()
   })
 
-  it('uses projected native value size and accounts for the selection', () => {
+  it('does not reject a small payload because the existing native value is large', () => {
     const input = document.createElement('textarea')
     input.dataset.pasteMaxBytes = '6'
     input.value = '123456'
     host.appendChild(input)
 
-    input.setSelectionRange(1, 5)
-    expect(dispatchPaste(input, 'abcd').defaultPrevented).toBe(false)
-
     input.setSelectionRange(6, 6)
-    expect(dispatchPaste(input, 'a').defaultPrevented).toBe(true)
+    expect(dispatchPaste(input, 'a').defaultPrevented).toBe(false)
   })
 
   it('honors a surface-specific character contract', () => {
@@ -75,19 +72,13 @@ describe('PasteAdmissionGuard', () => {
     expect(dispatchPaste(input, '💡💡').defaultPrevented).toBe(true)
   })
 
-  it('uses a contenteditable selection when projecting the result', () => {
+  it('does not reject a small payload because contenteditable text is already large', () => {
     const editable = document.createElement('div')
     editable.contentEditable = 'true'
     editable.dataset.pasteMaxBytes = '6'
     editable.textContent = '123456'
     host.appendChild(editable)
-    const range = document.createRange()
-    range.setStart(editable.firstChild as Text, 1)
-    range.setEnd(editable.firstChild as Text, 5)
-    const selection = document.getSelection()
-    selection?.removeAllRanges()
-    selection?.addRange(range)
-
-    expect(dispatchPaste(editable, 'abcd').defaultPrevented).toBe(false)
+
+    expect(dispatchPaste(editable, 'a').defaultPrevented).toBe(false)
   })
 })

apps/sim/app/_shell/paste-admission-guard.tsx

@@ -14,38 +14,12 @@ function finitePositiveAttribute(element: Element | null, name: string): number
   return Number.isFinite(value) && value > 0 ? value : undefined
 }
 
-function contentEditableSelection(element: HTMLElement): {
-  currentText: string
-  selectionStart: number
-  selectionEnd: number
-} {
-  const currentText = element.textContent ?? ''
-  const selection = document.getSelection()
-  if (!selection || selection.rangeCount === 0) {
-    return { currentText, selectionStart: currentText.length, selectionEnd: currentText.length }
-  }
-
-  const range = selection.getRangeAt(0)
-  if (!element.contains(range.startContainer) || !element.contains(range.endContainer)) {
-    return { currentText, selectionStart: currentText.length, selectionEnd: currentText.length }
-  }
-
-  const before = document.createRange()
-  before.selectNodeContents(element)
-  before.setEnd(range.startContainer, range.startOffset)
-  const selectionStart = before.toString().length
-  return {
-    currentText,
-    selectionStart,
-    selectionEnd: selectionStart + range.toString().length,
-  }
-}
-
 /**
- * Last-resort admission for every editable workspace surface. Specialized editors publish a larger
- * or smaller payload ceiling on an ancestor with `data-paste-max-bytes`; controls without one inherit
- * the Socket.IO-sized default. The capture listener runs before React, ProseMirror, Monaco, and xterm
- * can parse or render the clipboard value.
+ * Last-resort admission for every editable workspace surface. Specialized editors publish their
+ * downstream ceiling on an ancestor with `data-paste-max-bytes`; controls without one inherit a
+ * crash-only fallback. This layer bounds only the clipboard payload, so a small paste into an already
+ * large field keeps native behavior. Editors with a real result-size contract enforce it themselves.
+ * The capture listener runs before React, ProseMirror, Monaco, and xterm parse the clipboard value.
  */
 export function PasteAdmissionGuard() {
   const { toast: notify } = useToast()
@@ -68,31 +42,10 @@ export function PasteAdmissionGuard() {
         policyElement,
         'data-paste-max-characters'
       )
-      const nativeControl =
-        event.target instanceof HTMLInputElement || event.target instanceof HTMLTextAreaElement
-      const editableElement = event.target.closest<HTMLElement>(
-        '[contenteditable]:not([contenteditable="false"])'
-      )
-      const projectedValue = nativeControl
-        ? {
-            currentText: event.target.value,
-            selectionStart: event.target.selectionStart ?? event.target.value.length,
-            selectionEnd: event.target.selectionEnd ?? event.target.value.length,
-          }
-        : editableElement
-          ? contentEditableSelection(editableElement)
-          : null
       const admission = assessTextPaste({
         pastedText: text,
         maxPastedBytes,
         maxPastedCharacters,
-        ...(projectedValue
-          ? {
-              ...projectedValue,
-              maxResultBytes: maxPastedBytes,
-              maxResultCharacters: maxPastedCharacters,
-            }
-          : {}),
       })
       if (admission.accepted) return
 

apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/text-editor.tsx

@@ -593,18 +593,11 @@ export const TextEditor = memo(function TextEditor({
 
   const handleEditorPasteCapture = (event: ReactClipboardEvent<HTMLDivElement>) => {
     const pastedText = event.clipboardData.getData('text/plain')
-    const editor = monacoEditorRef.current
-    const model = editor?.getModel()
-    const selection = editor?.getSelection()
-    if (!pastedText || !model || !selection) return
+    if (!pastedText) return
 
     const admission = assessTextPaste({
       pastedText,
       maxPastedBytes: PASTE_LIMITS.TEXT_EDITOR_BYTES,
-      currentText: model.getValue(),
-      selectionStart: model.getOffsetAt(selection.getStartPosition()),
-      selectionEnd: model.getOffsetAt(selection.getEndPosition()),
-      maxResultBytes: PASTE_LIMITS.TEXT_EDITOR_BYTES,
     })
     if (admission.accepted) return
 

apps/sim/app/workspace/[workspaceId]/home/components/user-input/components/prompt-editor/prompt-editor.tsx

@@ -257,7 +257,6 @@ export function PromptEditor({
           placeholder={placeholder}
           aria-label={ariaLabel}
           rows={1}
-          maxLength={PASTE_LIMITS.CHAT_CHARACTERS}
           className={cn(
             TEXTAREA_BASE_CLASSES,
             usePlainTextMode && '!text-[var(--text-primary)]',

apps/sim/app/workspace/[workspaceId]/settings/components/secrets/components/secrets-manager/secrets-manager.tsx

@@ -39,7 +39,7 @@ const logger = createLogger('SecretsManager')
 
 const GRID_COLS = 'grid grid-cols-[minmax(0,1fr)_8px_minmax(0,1fr)_auto] items-center'
 const COL_SPAN_ALL = 'col-span-4'
-const MAX_ENV_PASTE_ROWS = 1_000
+const MAX_ENV_PASTE_ROWS = 10_000
 
 /** Copies a secret's name and confirms with a toast. */
 function copyName(key: string) {

apps/sim/lib/api/contracts/file-doc.ts

@@ -44,7 +44,7 @@ export const mergeFileDocBodySchema = z.object({
   /**
    * Base64-encoded `Y.encodeStateAsUpdate` of the live document as the relay currently holds it. The
    * bound is generous headroom over a max-size collab doc's Yjs state (base64-inflated), not a tuned
-   * limit — collab is gated to ≤256 KB documents client-side.
+   * limit — collaborative documents are gated to 5 MiB of markdown client-side.
    */
   docState: z
     .string()
@@ -89,7 +89,8 @@ export const persistFileDocBodySchema = z.object({
   userId: z.string().min(1, 'userId is required'),
   /**
    * Base64-encoded `Y.encodeStateAsUpdate` of the live document as the relay currently holds it — the
-   * bound matches the merge contract (generous base64 headroom over a ≤256 KB collab doc's Yjs state).
+   * bound matches the merge contract (generous base64 headroom over a 5 MiB collab document's Yjs
+   * state).
    */
   docState: z
     .string()

packages/utils/src/paste.test.ts

@@ -3,6 +3,7 @@ import {
   assessTextPaste,
   countPasteRows,
   formatPasteLimit,
+  PASTE_LIMITS,
   utf8ByteLength,
   utf8ByteLengthRange,
 } from './paste'
@@ -80,3 +81,10 @@ it('formats binary paste limits', () => {
   expect(formatPasteLimit(1_000_000)).toBe('1 MB')
   expect(formatPasteLimit(5 * 1024 * 1024)).toBe('5 MiB')
 })
+
+it('keeps non-contract paste ceilings in crash-only territory', () => {
+  expect(PASTE_LIMITS.DEFAULT_BYTES).toBe(32 * 1024 * 1024)
+  expect(PASTE_LIMITS.TEXT_EDITOR_BYTES).toBe(32 * 1024 * 1024)
+  expect(PASTE_LIMITS.TERMINAL_BYTES).toBe(8 * 1024 * 1024)
+  expect(PASTE_LIMITS.STRUCTURED_BYTES).toBe(32 * 1024 * 1024)
+})

packages/utils/src/paste.ts

@@ -1,18 +1,18 @@
 export const PASTE_LIMITS = {
-  /** Fallback for controls without a more specific downstream contract. */
-  DEFAULT_BYTES: 1_000_000,
-  /** Matches the realtime collaboration transport's single-message boundary. */
-  RICH_MARKDOWN_BYTES: 1_000_000,
-  /** Matches the existing inline CSV editor boundary. */
-  TEXT_EDITOR_BYTES: 5 * 1024 * 1024,
+  /** Crash-only fallback for controls without a more specific downstream contract. */
+  DEFAULT_BYTES: 32 * 1024 * 1024,
+  /** Matches the existing collaborative-document seed boundary. */
+  RICH_MARKDOWN_BYTES: 5 * 1024 * 1024,
+  /** Stays below the 50 MiB JSON request boundary while allowing genuinely large source files. */
+  TEXT_EDITOR_BYTES: 32 * 1024 * 1024,
   /** Matches the deployed chat request contract. */
   CHAT_CHARACTERS: 1_000_000,
   /** A Unicode scalar can occupy at most four UTF-8 bytes. */
   CHAT_BYTES: 4_000_000,
-  /** Keeps a single terminal input below the Socket.IO single-message boundary. */
-  TERMINAL_BYTES: 1_000_000,
-  /** Allows a sizeable grid while row and cell limits provide the primary bound. */
-  STRUCTURED_BYTES: 5 * 1024 * 1024,
+  /** Crash-only bound; admitted input is streamed to the PTY in 64 KiB chunks. */
+  TERMINAL_BYTES: 8 * 1024 * 1024,
+  /** The server's row ceiling remains the primary table bound. */
+  STRUCTURED_BYTES: 32 * 1024 * 1024,
 } as const
 
 export const PASTE_RENDER_THRESHOLDS = {