fix(chat): harden password reveal and close deployment lockout paths

Follow-ups from a security review of the password reveal endpoint. The
permission model itself was correct — the reveal is gated on workspace
admin via the canonical resolver, so derived org-admin access is honored.
These address secret handling and validation around it.

- Cap set-path passwords at the same 1024 chars the chat login accepts.
  Neither the input nor the schema bounded length, so a longer password
  saved fine and then failed the login POST on length before auth ran,
  locking every visitor out permanently.
- Discard the revealed password when the field is hidden. It previously
  stayed in state and in the input's DOM value with Copy still armed, so
  the field read as hidden while still handing out the plaintext.
- Evict the decrypted password from the mutation cache on unmount, and
  correct the TSDoc claiming it was never retained — it sat in the
  MutationCache for the default five minutes after the modal closed.
- Validate the password inside performChatDeploy, the writer both callers
  must use. The copilot deploy_chat tool bypasses the route contract and
  could still store a whitespace-only or over-long password, or create a
  password-protected chat with no password at all.
- Stop echoing raw decryption errors from the reveal endpoint.
- Only persist a new password when the chat ends up password-protected;
  PATCH { authType: 'email', password } used to re-arm the secret that the
  auth-type branch had just cleared.

Also replaces the hand-rolled copy state with useCopyToClipboard, which
fixes an unawaited clipboard write that surfaced as an unhandled rejection
and a "Copied" confirmation shown even when the write failed.

Co-Authored-By: Claude <noreply@anthropic.com>

Author: icecrasher321

apps/sim/app/api/chat/manage/[id]/password/route.test.ts

@@ -126,14 +126,16 @@ describe('Chat Password Reveal API Route', () => {
     expect(response.headers.get('Cache-Control')).toBe('private, no-store')
   })
 
-  it('should return 500 when decryption fails', async () => {
-    mockDecryptSecret.mockRejectedValue(new Error('Decryption failed'))
+  it('should return 500 without echoing the decryption error', async () => {
+    mockDecryptSecret.mockRejectedValue(
+      new Error('Invalid encrypted value format. Expected "iv:encrypted:authTag"')
+    )
 
     const response = await callGet()
 
     expect(response.status).toBe(500)
     const data = await response.json()
-    expect(data.error).toBe('Decryption failed')
+    expect(data.error).toBe('Failed to reveal chat password')
     expect(mockRecordAudit).not.toHaveBeenCalled()
   })
 })

apps/sim/app/api/chat/manage/[id]/password/route.ts

@@ -1,6 +1,5 @@
 import { AuditAction, AuditResourceType, recordAudit } from '@sim/audit'
 import { createLogger } from '@sim/logger'
-import { getErrorMessage } from '@sim/utils/errors'
 import type { NextRequest } from 'next/server'
 import { NextResponse } from 'next/server'
 import { getChatPasswordContract } from '@/lib/api/contracts/chats'
@@ -71,7 +70,12 @@ export const GET = withRouteHandler(
       return NextResponse.json({ password: decrypted }, { headers: PRIVATE_NO_STORE })
     } catch (error) {
       logger.error('Error revealing chat password:', error)
-      return createErrorResponse(getErrorMessage(error, 'Failed to reveal chat password'), 500)
+      /**
+       * Deliberately opaque: the only errors that reach here come from
+       * decryption, whose messages describe the stored ciphertext's shape.
+       * The logged error carries the detail for operators.
+       */
+      return createErrorResponse('Failed to reveal chat password', 500)
     }
   }
 )

apps/sim/app/api/chat/manage/[id]/route.ts

@@ -241,7 +241,13 @@ export const PATCH = withRouteHandler(
         }
       }
 
-      if (encryptedPassword) {
+      /**
+       * Only store a new password when the chat ends up password-protected.
+       * Applying it unconditionally re-armed the secret that the branch above
+       * just cleared, so `PATCH { authType: 'email', password }` persisted an
+       * encrypted password on an email-gated chat.
+       */
+      if (encryptedPassword && (authType ?? existingChat[0].authType) === 'password') {
         updateData.password = encryptedPassword
       }
 

apps/sim/components/ui/generated-password-input.test.tsx

@@ -6,6 +6,10 @@ import { createRoot, type Root } from 'react-dom/client'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { GeneratedPasswordInput } from '@/components/ui/generated-password-input'
 
+const { mockCopy } = vi.hoisted(() => ({
+  mockCopy: vi.fn(async () => true),
+}))
+
 vi.mock('@sim/emcn', () => ({
   Button: ({
     children,
@@ -34,6 +38,7 @@ vi.mock('@sim/emcn', () => ({
     Trigger: ({ children }: { children?: ReactNode }) => children,
     Content: () => null,
   },
+  useCopyToClipboard: () => ({ copied: false, copy: mockCopy }),
 }))
 
 let container: HTMLDivElement
@@ -43,17 +48,19 @@ interface RenderInputOptions {
   fetchCurrentPassword?: () => Promise<string>
   onChange?: (value: string) => void
   showGenerate?: boolean
+  value?: string
 }
 
 function renderInput({
   fetchCurrentPassword,
   onChange = vi.fn(),
   showGenerate = false,
+  value = '',
 }: RenderInputOptions = {}) {
   act(() => {
     root.render(
       <GeneratedPasswordInput
-        value=''
+        value={value}
         onChange={onChange}
         showGenerate={showGenerate}
         fetchCurrentPassword={fetchCurrentPassword}
@@ -99,7 +106,7 @@ describe('GeneratedPasswordInput', () => {
     expect(passwordInput()).toHaveAttribute('placeholder', '••••••••')
   })
 
-  it('fetches the saved password on reveal and reuses it when toggled', async () => {
+  it('fetches the saved password on reveal', async () => {
     const fetchCurrentPassword = vi.fn().mockResolvedValue('saved-secret')
 
     renderInput({ fetchCurrentPassword })
@@ -108,12 +115,37 @@ describe('GeneratedPasswordInput', () => {
     expect(fetchCurrentPassword).toHaveBeenCalledOnce()
     expect(passwordInput()).toHaveAttribute('type', 'text')
     expect(passwordInput()).toHaveValue('saved-secret')
+  })
+
+  it('discards the saved password when hidden and re-fetches on the next reveal', async () => {
+    const fetchCurrentPassword = vi.fn().mockResolvedValue('saved-secret')
+
+    renderInput({ fetchCurrentPassword })
+    await act(async () => passwordButton('Show password').click())
 
     act(() => passwordButton('Hide password').click())
+
     expect(passwordInput()).toHaveAttribute('type', 'password')
+    expect(passwordInput()).toHaveValue('')
+    expect(passwordInput()).toHaveAttribute('placeholder', '••••••••')
+    expect(passwordButton('Copy password')).toBeDisabled()
 
     await act(async () => passwordButton('Show password').click())
-    expect(fetchCurrentPassword).toHaveBeenCalledOnce()
+
+    expect(fetchCurrentPassword).toHaveBeenCalledTimes(2)
+    expect(passwordInput()).toHaveValue('saved-secret')
+  })
+
+  it('keeps an edited value when hidden', async () => {
+    const fetchCurrentPassword = vi.fn().mockResolvedValue('saved-secret')
+    const onChange = vi.fn()
+
+    renderInput({ fetchCurrentPassword, onChange, value: 'typed-secret' })
+    await act(async () => passwordButton('Show password').click())
+    act(() => passwordButton('Hide password').click())
+
+    expect(fetchCurrentPassword).not.toHaveBeenCalled()
+    expect(passwordInput()).toHaveValue('typed-secret')
   })
 
   it('stays masked when loading the saved password fails', async () => {

apps/sim/components/ui/generated-password-input.tsx

@@ -1,7 +1,7 @@
 'use client'
 
-import { useEffect, useState } from 'react'
-import { Button, ChipInput, Loader, Tooltip } from '@sim/emcn'
+import { useState } from 'react'
+import { Button, ChipInput, Loader, Tooltip, useCopyToClipboard } from '@sim/emcn'
 import { Check, Clipboard, Eye, EyeOff, RefreshCw } from 'lucide-react'
 import { generatePassword } from '@/lib/core/security/encryption'
 
@@ -41,24 +41,13 @@ export function GeneratedPasswordInput({
   fetchCurrentPassword,
 }: GeneratedPasswordInputProps) {
   const [showPassword, setShowPassword] = useState(false)
-  const [copySuccess, setCopySuccess] = useState(false)
   const [currentPassword, setCurrentPassword] = useState<string | null>(null)
   const [isFetchingCurrent, setIsFetchingCurrent] = useState(false)
-
-  useEffect(() => {
-    if (!copySuccess) return
-    const timer = setTimeout(() => setCopySuccess(false), 2000)
-    return () => clearTimeout(timer)
-  }, [copySuccess])
+  const { copied, copy } = useCopyToClipboard()
 
   const displayValue = currentPassword ?? value
   const displayPlaceholder = fetchCurrentPassword && !displayValue ? MASKED_PASSWORD : placeholder
 
-  const copyToClipboard = () => {
-    navigator.clipboard.writeText(displayValue)
-    setCopySuccess(true)
-  }
-
   const handleChange = (nextValue: string) => {
     setCurrentPassword(null)
     onChange(nextValue)
@@ -71,6 +60,14 @@ export function GeneratedPasswordInput({
   const toggleShowPassword = async () => {
     if (showPassword) {
       setShowPassword(false)
+      /**
+       * Discard the fetched password instead of masking it. Keeping it would
+       * leave the plaintext in the input's DOM value and keep Copy armed while
+       * the field reads as hidden. A later reveal re-fetches, which also keeps
+       * the audit log at one entry per disclosure. An edited value lives in
+       * `value` and is deliberately untouched.
+       */
+      setCurrentPassword(null)
       return
     }
 
@@ -124,16 +121,16 @@ export function GeneratedPasswordInput({
               <Button
                 type='button'
                 variant='ghost'
-                onClick={copyToClipboard}
+                onClick={() => copy(displayValue)}
                 disabled={!displayValue || disabled}
                 aria-label='Copy password'
                 className='!p-1.5'
               >
-                {copySuccess ? <Check className='size-3' /> : <Clipboard className='size-3' />}
+                {copied ? <Check className='size-3' /> : <Clipboard className='size-3' />}
               </Button>
             </Tooltip.Trigger>
             <Tooltip.Content>
-              <span>{copySuccess ? 'Copied' : 'Copy'}</span>
+              <span>{copied ? 'Copied' : 'Copy'}</span>
             </Tooltip.Content>
           </Tooltip.Root>
           <Tooltip.Root>

apps/sim/hooks/queries/chats.ts

@@ -385,12 +385,18 @@ interface RevealChatPasswordVariables {
 }
 
 /**
- * Mutation hook that fetches a chat deployment's current password for
- * workspace admins. Modeled as a mutation (despite the GET) so the decrypted
- * password is never retained in the query cache.
+ * Mutation hook that fetches a chat deployment's current password for workspace
+ * admins. Modeled as a mutation (despite the GET) because revealing a secret is
+ * an audited, explicitly-triggered action, not cacheable read state.
+ *
+ * `gcTime: 0` evicts the decrypted password from the mutation cache as soon as
+ * the last observer unmounts, rather than letting it sit there for the default
+ * five minutes after the deploy modal closes. While the modal is open the caller
+ * holds the plaintext anyway, and it discards it when the field is hidden.
  */
 export function useRevealChatPassword() {
   return useMutation({
+    gcTime: 0,
     mutationFn: async ({ chatId }: RevealChatPasswordVariables): Promise<string> => {
       const result = await requestJson(getChatPasswordContract, { params: { id: chatId } })
       return result.password

apps/sim/lib/api/contracts/chats.password.test.ts

@@ -0,0 +1,63 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import {
+  chatDeploymentPasswordSchema,
+  createChatBodySchema,
+  deployedChatAuthBodySchema,
+  deployedChatPostBodySchema,
+  updateChatBodySchema,
+} from '@/lib/api/contracts/chats'
+
+const createBody = {
+  workflowId: 'wf-1',
+  identifier: 'my-chat',
+  title: 'Support',
+  customizations: { primaryColor: 'var(--brand-hover)', welcomeMessage: 'Hi' },
+}
+
+describe('chat deployment password contract', () => {
+  it('accepts the empty string, which means "keep the stored password"', () => {
+    expect(chatDeploymentPasswordSchema.safeParse('').success).toBe(true)
+  })
+
+  it('rejects a whitespace-only password', () => {
+    const result = chatDeploymentPasswordSchema.safeParse('   ')
+    expect(result.success).toBe(false)
+    expect(result.error?.issues[0].message).toBe('Password cannot contain only whitespace')
+  })
+
+  it('preserves surrounding whitespace, which login compares byte-exact', () => {
+    expect(chatDeploymentPasswordSchema.parse('  hunter2  ')).toBe('  hunter2  ')
+  })
+
+  /**
+   * The security-relevant invariant: a password long enough to save must still
+   * be short enough to submit. If the set path outgrew the login path, the
+   * deployment would be permanently unreachable — the login POST would 400 on
+   * length before authentication ever ran.
+   */
+  it('caps length at the same boundary the deployed-chat login enforces', () => {
+    const atLimit = 'a'.repeat(1024)
+    const overLimit = 'a'.repeat(1025)
+
+    expect(chatDeploymentPasswordSchema.safeParse(atLimit).success).toBe(true)
+    expect(chatDeploymentPasswordSchema.safeParse(overLimit).success).toBe(false)
+
+    expect(deployedChatAuthBodySchema.safeParse({ password: atLimit }).success).toBe(true)
+    expect(deployedChatPostBodySchema.safeParse({ password: atLimit }).success).toBe(true)
+  })
+
+  it('applies to both the create and update bodies', () => {
+    const tooLong = 'a'.repeat(1025)
+
+    expect(createChatBodySchema.safeParse({ ...createBody, password: '   ' }).success).toBe(false)
+    expect(createChatBodySchema.safeParse({ ...createBody, password: tooLong }).success).toBe(false)
+    expect(createChatBodySchema.safeParse({ ...createBody, password: 'ok' }).success).toBe(true)
+
+    expect(updateChatBodySchema.safeParse({ password: '   ' }).success).toBe(false)
+    expect(updateChatBodySchema.safeParse({ password: tooLong }).success).toBe(false)
+    expect(updateChatBodySchema.safeParse({ password: '' }).success).toBe(true)
+  })
+})

apps/sim/lib/api/contracts/chats.ts

@@ -4,8 +4,22 @@ import { defineRouteContract } from '@/lib/api/contracts/types'
 export const chatAuthTypeSchema = z.enum(['public', 'password', 'email', 'sso'])
 export type ChatAuthType = z.output<typeof chatAuthTypeSchema>
 
+/**
+ * Shared cap for chat deployment passwords. The set path and the deployed-chat
+ * login path must agree: a password long enough to save but too long to submit
+ * would lock every visitor out of the deployment permanently.
+ */
+const MAX_CHAT_PASSWORD_CHARS = 1024
+
+/**
+ * Password accepted when setting or changing a chat deployment's password. The
+ * empty string is allowed and means "keep the stored password"; a whitespace-only
+ * value is rejected because the login form refuses to submit one, which would
+ * strand the deployment behind an unenterable password.
+ */
 export const chatDeploymentPasswordSchema = z
   .string()
+  .max(MAX_CHAT_PASSWORD_CHARS, 'Password is too long')
   .refine(
     (password) => password.length === 0 || password.trim().length > 0,
     'Password cannot contain only whitespace'
@@ -127,7 +141,7 @@ export const deployedChatConfigSchema = z.object({
 export type DeployedChatConfig = z.output<typeof deployedChatConfigSchema>
 
 export const deployedChatAuthBodySchema = z.object({
-  password: z.string().max(1024, 'Password is too long').optional(),
+  password: z.string().max(MAX_CHAT_PASSWORD_CHARS, 'Password is too long').optional(),
   email: z.string().email('Invalid email format').optional().or(z.literal('')),
 })
 export type DeployedChatAuthBody = z.input<typeof deployedChatAuthBodySchema>
@@ -149,7 +163,7 @@ export const deployedChatFileSchema = z.object({
 
 export const deployedChatPostBodySchema = z.object({
   input: z.string().max(MAX_CHAT_INPUT_CHARS, 'Input is too long').optional(),
-  password: z.string().max(1024, 'Password is too long').optional(),
+  password: z.string().max(MAX_CHAT_PASSWORD_CHARS, 'Password is too long').optional(),
   email: z.string().email('Invalid email format').optional().or(z.literal('')),
   conversationId: z.string().max(256, 'Conversation ID is too long').optional(),
   files: z