fix(mssql,editor): measure the response cap in UTF-8 and stop search from unmasking secrets

capRecordset sized rows with JSON.stringify(row).length, which counts UTF-16
code units while the emitted body carries raw UTF-8. CJK is the worst case at
3 bytes per unit, so a recordset admitted as 10 MB serialized to 28 MB. Rows
are now measured with Buffer.byteLength, serialized once each, with array
punctuation charged exactly and a reserve held back for the response envelope.

Workflow search revealed masked credentials without the user touching the
field: the search panel keeps focus in its own input and only scrolls the
match into view, so typing a guess painted a private key on screen. The index
is built client-side from values already in page memory, so this was never a
privilege boundary, but masking exists to prevent incidental display and a
screenshare-visible reveal defeats it. Focus is now the only reveal, applied
through one shared policy across all four renderers.

Author: waleedlatif1

apps/sim/app/api/tools/mssql/utils.test.ts

@@ -558,6 +558,50 @@ describe('executeQuery result caps', () => {
     expect(result.truncated).toBe(true)
     expect(result.truncationReason).toMatch(/exceeds the 10 MB response ceiling/)
   })
+
+  /**
+   * `String.length` counts UTF-16 code units and the response is emitted as
+   * UTF-8, so a CJK recordset costs three bytes for every unit the old
+   * accounting charged one for. Measured with `length` these rows fit; measured
+   * as the bytes that actually go on the wire they are ~3x over.
+   */
+  it('bounds a multibyte recordset by UTF-8 bytes, not UTF-16 code units', async () => {
+    const cjk = Array.from({ length: 20 }, () => ({ blob: '世'.repeat(1024 * 1024) }))
+    const result = await executeQuery(makeCapPool(cjk), 'SELECT 1')
+
+    expect(Buffer.byteLength(JSON.stringify(result.rows), 'utf8')).toBeLessThanOrEqual(
+      10 * 1024 * 1024
+    )
+    expect(result.rows.length).toBeGreaterThan(0)
+    expect(result.truncated).toBe(true)
+  })
+
+  /** Emoji are 4 UTF-8 bytes across 2 surrogate code units — a 2:1 undercount. */
+  it('bounds an astral-plane recordset by UTF-8 bytes', async () => {
+    const emoji = Array.from({ length: 20 }, () => ({ blob: '😀'.repeat(1024 * 1024) }))
+    const result = await executeQuery(makeCapPool(emoji), 'SELECT 1')
+
+    expect(Buffer.byteLength(JSON.stringify(result.rows), 'utf8')).toBeLessThanOrEqual(
+      10 * 1024 * 1024
+    )
+    expect(result.truncated).toBe(true)
+  })
+
+  /**
+   * Rows sized to divide the ceiling exactly, so an accounting that ignores the
+   * array's commas and the fields around it lands precisely on the limit and the
+   * body it emits is over by the punctuation and the envelope.
+   */
+  it('keeps the emitted body inside the ceiling once array and envelope overhead is counted', async () => {
+    const rowPayload = 'x'.repeat(2048 - '{"blob":""}'.length)
+    const packed = Array.from({ length: 6000 }, () => ({ blob: rowPayload }))
+    const result = await executeQuery(makeCapPool(packed), 'SELECT 1')
+
+    const body = toRowsResponseBody(result, 'Query executed successfully. rows returned.')
+
+    expect(result.truncated).toBe(true)
+    expect(Buffer.byteLength(JSON.stringify(body), 'utf8')).toBeLessThanOrEqual(10 * 1024 * 1024)
+  })
 })
 
 describe('toRowsResponseBody truncation disclosure', () => {

apps/sim/app/api/tools/mssql/utils.ts

@@ -161,12 +161,44 @@ function toBindableValue(value: unknown): unknown {
 const MSSQL_MAX_RESULT_ROWS = 10_000
 const MSSQL_MAX_RESULT_BYTES = 10 * 1024 * 1024
 
+/**
+ * Bytes held back from {@link MSSQL_MAX_RESULT_BYTES} for the part of the
+ * response body that is not a row.
+ *
+ * {@link toRowsResponseBody} wraps `rows` in `message`, `rowCount`, and — when
+ * the recordset was capped — `truncated` and `truncationReason`, none of which
+ * the per-row accounting can see. Those are a few hundred bytes at their
+ * longest (the truncation prose is the bulk of it), so the reserve is set an
+ * order of magnitude above the worst case and costs 0.04% of the ceiling. The
+ * alternative, serializing the assembled body to check it, would re-serialize
+ * the whole recordset a second time for no useful precision.
+ */
+const MSSQL_RESPONSE_ENVELOPE_BYTES = 4096
+
+/** What the serialized `rows` array itself may occupy. */
+const MSSQL_MAX_ROWS_BYTES = MSSQL_MAX_RESULT_BYTES - MSSQL_RESPONSE_ENVELOPE_BYTES
+
 /**
  * Truncates a recordset to the row and byte ceilings.
  *
- * Measures with `JSON.stringify` on each row because that is what the route will
- * do anyway, so the number bounds the response the caller actually receives
- * rather than an in-memory estimate that does not correspond to it.
+ * Measures each row with `JSON.stringify` because that is what the route will do
+ * anyway, so the number bounds the response the caller actually receives rather
+ * than an in-memory estimate that does not correspond to it. Each row is
+ * serialized exactly once and its cost accumulated, rather than re-serializing
+ * the growing array per row, which would be quadratic on a large recordset.
+ *
+ * The size is `Buffer.byteLength(..., 'utf8')`, not `String.length`. `length`
+ * counts UTF-16 code units while `NextResponse.json` emits UTF-8, and every
+ * character above U+007F costs more bytes than code units — worst case 3:1, for
+ * the U+0800–U+FFFF range that holds CJK, so a recordset of Chinese text passed
+ * a 10 MB `length` budget while serializing to nearly 30 MB. (Astral characters
+ * such as emoji are only 2:1: 4 bytes across 2 surrogate code units.)
+ *
+ * The array's own punctuation is counted too — one byte per row covers the
+ * opening `[` for the first row and the separating `,` for each one after it,
+ * with the leading byte standing in for the closing `]` — and
+ * {@link MSSQL_RESPONSE_ENVELOPE_BYTES} covers the fields around it. Without
+ * both, a result packed exactly to the ceiling still emitted a body over it.
  *
  * A row is admitted only when it still fits, so a single row larger than the
  * byte ceiling is dropped rather than admitted as a lone exception — otherwise
@@ -179,13 +211,19 @@ function capRecordset(rows: unknown[]): { rows: unknown[]; truncated: boolean }
   if (rows.length === 0) return { rows, truncated: false }
 
   const capped: unknown[] = []
-  let bytes = 0
+  /** The closing `]`; each row below pays for its own `[` or `,`. */
+  let bytes = 1
 
   for (const row of rows) {
     if (capped.length >= MSSQL_MAX_RESULT_ROWS) break
-    const rowBytes = JSON.stringify(row)?.length ?? 0
-    if (bytes + rowBytes > MSSQL_MAX_RESULT_BYTES) break
-    bytes += rowBytes
+    const serialized = JSON.stringify(row)
+    /**
+     * `JSON.stringify` answers `undefined` for a value it cannot represent, but
+     * an array element in that position serializes as the four bytes of `null`.
+     */
+    const rowBytes = serialized === undefined ? 4 : Buffer.byteLength(serialized, 'utf8')
+    if (bytes + rowBytes + 1 > MSSQL_MAX_ROWS_BYTES) break
+    bytes += rowBytes + 1
     capped.push(row)
   }
 

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/code/code.test.tsx

@@ -14,8 +14,9 @@ globalThis.ResizeObserver = class {
   disconnect() {}
 } as unknown as typeof ResizeObserver
 
-const { SECRET } = vi.hoisted(() => ({
+const { SECRET, searchTargetRef } = vi.hoisted(() => ({
   SECRET: '-----BEGIN OPENSSH PRIVATE KEY-----\nb3BlbnNzaC1rZXktdjE\n-----END-----',
+  searchTargetRef: { current: null as Record<string, unknown> | null },
 }))
 
 vi.mock('@sim/emcn', () => ({
@@ -107,7 +108,7 @@ vi.mock(
 
 vi.mock(
   '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/providers/active-search-target-provider',
-  () => ({ useActiveSearchTarget: () => null })
+  () => ({ useActiveSearchTarget: () => searchTargetRef.current })
 )
 
 vi.mock(
@@ -165,6 +166,7 @@ let container: HTMLDivElement
 let root: Root
 
 beforeEach(() => {
+  searchTargetRef.current = null
   container = document.createElement('div')
   document.body.appendChild(container)
   root = createRoot(container)
@@ -190,6 +192,18 @@ function mount(password: boolean) {
 
 const highlighted = () => container.querySelector('[data-testid="code-highlight"]')?.innerHTML ?? ''
 
+/** A live workflow-search hit on the base64 body of the secret. */
+const SECRET_MATCH = 'b3BlbnNzaC1rZXktdjE'
+const SECRET_MATCH_START = SECRET.indexOf(SECRET_MATCH)
+const SECRET_SEARCH_TARGET = {
+  subBlockId: 'privateKey',
+  targetKind: 'subblock',
+  valuePath: [],
+  query: SECRET_MATCH,
+  rawValue: SECRET_MATCH,
+  range: { start: SECRET_MATCH_START, end: SECRET_MATCH_START + SECRET_MATCH.length },
+}
+
 describe('Code password masking', () => {
   it('conceals the editor contents while unfocused', () => {
     mount(true)
@@ -220,4 +234,23 @@ describe('Code password masking', () => {
     expect(highlighted()).toContain('BEGIN OPENSSH PRIVATE KEY')
     expect(highlighted()).not.toContain('•')
   })
+
+  it('stays concealed while workflow search targets a match inside the secret', () => {
+    searchTargetRef.current = SECRET_SEARCH_TARGET
+
+    mount(true)
+
+    expect(highlighted()).not.toContain('b3BlbnNzaC1rZXktdjE')
+    expect(highlighted()).not.toContain('BEGIN OPENSSH PRIVATE KEY')
+    expect(highlighted()).toContain('•')
+  })
+
+  it('highlights a targeted match when the field holds no secret', () => {
+    searchTargetRef.current = SECRET_SEARCH_TARGET
+
+    mount(false)
+
+    expect(highlighted()).toContain('<mark')
+    expect(highlighted()).toContain('b3BlbnNzaC1rZXktdjE')
+  })
 })

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/code/code.tsx

@@ -30,7 +30,10 @@ import {
   getValidWorkflowSearchRange,
   type WorkflowSearchTextHighlight,
 } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/formatted-text'
-import { maskSecretText } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/password-mask'
+import {
+  maskSecretText,
+  shouldMaskSecretValue,
+} from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/password-mask'
 import {
   checkTagTrigger,
   TagDropdown,
@@ -250,7 +253,7 @@ interface CodeProps {
   blockId: string
   subBlockId: string
   placeholder?: string
-  /** Whether to conceal the value until the editor is focused */
+  /** Whether to conceal the value except while the editor is focused */
   password?: boolean
   language?: 'javascript' | 'json' | 'python' | 'shell'
   generationType?: GenerationType
@@ -763,6 +766,8 @@ export const Code = memo(function Code({
     valuePath: [],
   })
 
+  const shouldMask = shouldMaskSecretValue({ password, isFocused })
+
   const highlightCode = useMemo(
     () =>
       createHighlightFunction(
@@ -964,7 +969,7 @@ export const Code = memo(function Code({
             onKeyDown={handleKeyDown}
             onFocus={handleEditorFocus}
             onBlur={handleEditorBlur}
-            highlight={password && !isFocused ? highlightMaskedCode : highlightCode}
+            highlight={shouldMask ? highlightMaskedCode : highlightCode}
             {...getCodeEditorProps({ isStreaming: isAiStreaming, isPreview, disabled })}
           />
 

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/long-input/long-input.test.tsx

@@ -2,10 +2,11 @@
  * @vitest-environment node
  */
 import { renderToStaticMarkup } from 'react-dom/server'
-import { describe, expect, it, vi } from 'vitest'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
 
-const { SECRET } = vi.hoisted(() => ({
+const { SECRET, searchTargetRef } = vi.hoisted(() => ({
   SECRET: '-----BEGIN OPENSSH PRIVATE KEY-----\nb3BlbnNzaC1rZXk\n-----END-----',
+  searchTargetRef: { current: null as Record<string, unknown> | null },
 }))
 
 vi.mock('@sim/emcn', () => ({
@@ -60,7 +61,7 @@ vi.mock(
 vi.mock(
   '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/providers/active-search-target-provider',
   () => ({
-    useActiveSearchTarget: () => null,
+    useActiveSearchTarget: () => searchTargetRef.current,
   })
 )
 
@@ -97,13 +98,20 @@ import type { SubBlockConfig } from '@/blocks/types'
 
 const config: SubBlockConfig = { id: 'privateKey', type: 'long-input', password: true }
 
+/** A live workflow-search hit on the base64 body of the secret. */
+const MATCH_START = SECRET.indexOf('b3BlbnNzaC1rZXk')
+
 function render(password: boolean) {
   return renderToStaticMarkup(
     <LongInput blockId='block-1' subBlockId='privateKey' config={config} password={password} />
   )
 }
 
 describe('LongInput password masking', () => {
+  beforeEach(() => {
+    searchTargetRef.current = null
+  })
+
   it('conceals the value in both the textarea and the overlay when unfocused', () => {
     const html = render(true)
 
@@ -118,4 +126,39 @@ describe('LongInput password masking', () => {
     expect(html).toContain('BEGIN OPENSSH PRIVATE KEY')
     expect(html).not.toContain('•')
   })
+
+  it('stays concealed while workflow search targets a match inside the secret', () => {
+    searchTargetRef.current = {
+      blockId: 'block-1',
+      subBlockId: 'privateKey',
+      targetKind: 'subblock',
+      valuePath: [],
+      query: 'b3BlbnNzaC1rZXk',
+      rawValue: 'b3BlbnNzaC1rZXk',
+      range: { start: MATCH_START, end: MATCH_START + 'b3BlbnNzaC1rZXk'.length },
+    }
+
+    const html = render(true)
+
+    expect(html).not.toContain('b3BlbnNzaC1rZXk')
+    expect(html).not.toContain('BEGIN OPENSSH PRIVATE KEY')
+    expect(html).toContain('•')
+  })
+
+  it('highlights a workflow-search match when the field holds no secret', () => {
+    searchTargetRef.current = {
+      blockId: 'block-1',
+      subBlockId: 'privateKey',
+      targetKind: 'subblock',
+      valuePath: [],
+      query: 'b3BlbnNzaC1rZXk',
+      rawValue: 'b3BlbnNzaC1rZXk',
+      range: { start: MATCH_START, end: MATCH_START + 'b3BlbnNzaC1rZXk'.length },
+    }
+
+    const html = render(false)
+
+    expect(html).toContain('<mark')
+    expect(html).toContain('b3BlbnNzaC1rZXk')
+  })
 })

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/long-input/long-input.tsx

@@ -11,11 +11,11 @@ import { cn, Textarea } from '@sim/emcn'
 import { ChevronsUpDown, Wand } from '@sim/emcn/icons'
 import { createLogger } from '@sim/logger'
 import { Button } from '@/components/ui/button'
+import { formatDisplayText } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/formatted-text'
 import {
-  formatDisplayText,
-  getValidWorkflowSearchRange,
-} from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/formatted-text'
-import { maskSecretText } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/password-mask'
+  maskSecretText,
+  shouldMaskSecretValue,
+} from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/password-mask'
 import { SubBlockInputController } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/sub-block-input-controller'
 import { getActiveWorkflowSearchHighlight } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/workflow-search-highlight'
 import { useSubBlockInput } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/hooks/use-sub-block-input'
@@ -50,7 +50,7 @@ const MIN_HEIGHT_PX = 80
 interface LongInputProps {
   /** Placeholder text to display when empty */
   placeholder?: string
-  /** Whether to conceal the value until the textarea is focused */
+  /** Whether to conceal the value except while the textarea is focused */
   password?: boolean
   /** Unique identifier for the block */
   blockId: string
@@ -85,7 +85,7 @@ interface LongInputProps {
  * - Handles drag-and-drop for connections and variable references
  * - Provides environment variable and tag autocomplete
  * - Resizable with custom drag handle
- * - Password masking with reveal on focus
+ * - Password masking, revealed only while focused
  * - Integrates with ReactFlow for zoom control
  */
 export function LongInput({
@@ -200,13 +200,7 @@ export function LongInput({
   // During streaming, use local content; otherwise use the controller value
   const value = wandHook.isStreaming ? localContent : ctrl.valueString
 
-  /**
-   * A masked field reveals itself while focused so it stays editable, and while
-   * workflow search has an active match inside it so the hit is findable —
-   * matching the short-input treatment of the same flag.
-   */
-  const shouldMask =
-    Boolean(password) && !isFocused && !getValidWorkflowSearchRange(value, workflowSearchHighlight)
+  const shouldMask = shouldMaskSecretValue({ password, isFocused })
   const displayValue = shouldMask ? maskSecretText(value) : value
 
   const handleBlur = useCallback(() => {

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/password-mask/index.ts

@@ -1 +1,5 @@
-export { maskSecretText, PASSWORD_MASKED_SUBBLOCK_TYPES } from './password-mask'
+export {
+  maskSecretText,
+  PASSWORD_MASKED_SUBBLOCK_TYPES,
+  shouldMaskSecretValue,
+} from './password-mask'