fix(elasticsearch): register an error extractor so auth headers stay out of errors

A 401 dumped the whole error blob, including WWW-Authenticate, into the
user-visible message. Replaces a tautological assertion on
transformResponse.toString() with one that drives executeTool and proves
the executor throws on a 404 before transformResponse runs.

Author: waleedlatif1

apps/sim/app/api/tools/google_drive/export/path-safety.test.ts

@@ -84,6 +84,10 @@ beforeEach(() => {
 
 describe('POST /api/tools/google_drive/export traversal safety', () => {
   it.each(REJECTED)('rejects fileId %j with a clean 400 and no outbound request', async (fileId) => {
+    mockSecureFetchWithPinnedIP
+      .mockResolvedValueOnce(metadataResponse('doc-1'))
+      .mockResolvedValueOnce(exportResponse())
+
     const response = await POST(createMockRequest('POST', bodyFor(fileId)))
 
     expect(response.status).toBe(400)

apps/sim/app/api/tools/google_drive/export/route.ts

@@ -17,6 +17,7 @@ import {
   MAX_EXPORT_BYTES,
   VALID_EXPORT_FORMATS,
 } from '@/tools/google_drive/utils'
+import { safeUrlPathSegment } from '@/tools/url-path'
 
 export const dynamic = 'force-dynamic'
 
@@ -62,9 +63,22 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
     const { accessToken, fileId, mimeType: exportMimeType, fileName } = parsed.data.body
     const authHeader = `Bearer ${accessToken}`
 
+    let fileIdSegment: string
+    try {
+      fileIdSegment = safeUrlPathSegment(fileId, 'fileId')
+    } catch (error) {
+      logger.warn(`[${requestId}] Rejected unsafe fileId`, {
+        error: getErrorMessage(error, 'Invalid fileId'),
+      })
+      return NextResponse.json(
+        { success: false, error: getErrorMessage(error, 'Invalid fileId') },
+        { status: 400 }
+      )
+    }
+
     logger.info(`[${requestId}] Getting file metadata from Google Drive`, { fileId })
 
-    const metadataUrl = `https://www.googleapis.com/drive/v3/files/${encodeURIComponent(fileId)}?fields=${ALL_FILE_FIELDS}&supportsAllDrives=true`
+    const metadataUrl = `https://www.googleapis.com/drive/v3/files/${fileIdSegment}?fields=${ALL_FILE_FIELDS}&supportsAllDrives=true`
     const metadataUrlValidation = await validateUrlWithDNS(metadataUrl, 'metadataUrl')
     if (!metadataUrlValidation.isValid) {
       return NextResponse.json(
@@ -123,7 +137,7 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
       exportFormat: exportMimeType,
     })
 
-    const exportUrl = `https://www.googleapis.com/drive/v3/files/${encodeURIComponent(fileId)}/export?mimeType=${encodeURIComponent(exportMimeType)}`
+    const exportUrl = `https://www.googleapis.com/drive/v3/files/${fileIdSegment}/export?mimeType=${encodeURIComponent(exportMimeType)}`
     const exportUrlValidation = await validateUrlWithDNS(exportUrl, 'exportUrl')
     if (!exportUrlValidation.isValid) {
       return NextResponse.json(

apps/sim/app/api/tools/google_vault/download-export-file/path-safety.test.ts

@@ -0,0 +1,162 @@
+/**
+ * @vitest-environment node
+ *
+ * Guards the Google Vault export-file download route against a dot-segment
+ * pop, WITHOUT weakening its `%2F` encoding.
+ *
+ * A GCS object name legitimately contains `/`, and the JSON API requires it
+ * percent-encoded as `%2F` inside the single `/o/{object}` segment. So
+ * `safeUrlPath` (which preserves `/` as a separator) would be the wrong tool
+ * here and `encodeURIComponent` must stay. What `encodeURIComponent` does not
+ * stop is a value that is exactly `.` or `..`: those characters are
+ * unreserved, survive encoding, and the WHATWG parser removes the segment
+ * afterwards — `/b/{bucket}/o/..` resolves to `/b/{bucket}/`, the object
+ * *list* endpoint, with the caller's bearer token attached.
+ *
+ * Only the whole value is checked, not each `/`-separated component: because
+ * the value becomes one `%2F`-encoded segment, an interior `..` never forms a
+ * URL segment and an object literally named `a/../b` is legally addressable.
+ *
+ * `objectName` and `bucketName` are `visibility: 'user-only'` on
+ * `google_vault_download_export_file`, so this is not LLM-reachable — lower
+ * severity than the Drive `fileId` sites, fixed for the same reason.
+ */
+import {
+  createMockRequest,
+  hybridAuthMockFns,
+  inputValidationMock,
+  inputValidationMockFns,
+} from '@sim/testing'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+vi.mock('@/lib/core/security/input-validation.server', () => inputValidationMock)
+
+import { POST } from '@/app/api/tools/google_vault/download-export-file/route'
+
+const { mockValidateUrlWithDNS, mockSecureFetchWithPinnedIP } = inputValidationMockFns
+
+const PINNED_IP = '93.184.216.34'
+const REJECTED = ['..', '.', '  ..  '] as const
+
+function downloadResponse() {
+  return {
+    ok: true,
+    status: 200,
+    statusText: '',
+    headers: new Headers({ 'content-type': 'application/zip' }),
+    body: null,
+    text: async () => '',
+    json: async () => ({}),
+    arrayBuffer: async () => new ArrayBuffer(4),
+  }
+}
+
+function requestedUrl(): string {
+  return String(mockValidateUrlWithDNS.mock.calls[0][0])
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  hybridAuthMockFns.mockCheckInternalAuth.mockResolvedValue({
+    success: true,
+    userId: 'user-1',
+    authType: 'internal_jwt',
+  })
+  mockValidateUrlWithDNS.mockResolvedValue({
+    isValid: true,
+    resolvedIP: PINNED_IP,
+    originalHostname: 'storage.googleapis.com',
+  })
+})
+
+describe('POST /api/tools/google_vault/download-export-file traversal safety', () => {
+  it.each(REJECTED)(
+    'rejects objectName %j with a clean 400 and no outbound request',
+    async (objectName) => {
+      mockSecureFetchWithPinnedIP.mockResolvedValueOnce(downloadResponse())
+
+      const response = await POST(
+        createMockRequest('POST', {
+          accessToken: 'token-123',
+          matterId: 'matter-1',
+          bucketName: 'vault-bucket',
+          objectName,
+        })
+      )
+
+      expect(response.status).toBe(400)
+      const data = (await response.json()) as { success: boolean; error: string }
+      expect(data.success).toBe(false)
+      expect(data.error).toMatch(/objectName/)
+      expect(mockValidateUrlWithDNS).not.toHaveBeenCalled()
+      expect(mockSecureFetchWithPinnedIP).not.toHaveBeenCalled()
+    }
+  )
+
+  it.each(REJECTED)(
+    'rejects bucketName %j with a clean 400 and no outbound request',
+    async (bucketName) => {
+      mockSecureFetchWithPinnedIP.mockResolvedValueOnce(downloadResponse())
+
+      const response = await POST(
+        createMockRequest('POST', {
+          accessToken: 'token-123',
+          matterId: 'matter-1',
+          bucketName,
+          objectName: 'exports/file.zip',
+        })
+      )
+
+      expect(response.status).toBe(400)
+      const data = (await response.json()) as { success: boolean; error: string }
+      expect(data.success).toBe(false)
+      expect(data.error).toMatch(/bucketName/)
+      expect(mockValidateUrlWithDNS).not.toHaveBeenCalled()
+      expect(mockSecureFetchWithPinnedIP).not.toHaveBeenCalled()
+    }
+  )
+
+  it('keeps a nested object name as one %2F-encoded segment, byte-identical to today', async () => {
+    mockSecureFetchWithPinnedIP.mockResolvedValueOnce(downloadResponse())
+
+    const response = await POST(
+      createMockRequest('POST', {
+        accessToken: 'token-123',
+        matterId: 'matter-1',
+        bucketName: 'vault-bucket',
+        objectName: 'matter-1/exports/file name.zip',
+      })
+    )
+    expect(response.status).toBe(200)
+
+    expect(requestedUrl()).toBe(
+      'https://storage.googleapis.com/storage/v1/b/vault-bucket/o/matter-1%2Fexports%2Ffile%20name.zip?alt=media'
+    )
+    const segments = new URL(requestedUrl()).pathname.split('/').filter(Boolean)
+    expect(segments).toEqual([
+      'storage',
+      'v1',
+      'b',
+      'vault-bucket',
+      'o',
+      'matter-1%2Fexports%2Ffile%20name.zip',
+    ])
+  })
+
+  it('preserves an interior ".." component, which never forms a URL segment', async () => {
+    mockSecureFetchWithPinnedIP.mockResolvedValueOnce(downloadResponse())
+
+    const response = await POST(
+      createMockRequest('POST', {
+        accessToken: 'token-123',
+        matterId: 'matter-1',
+        bucketName: 'vault-bucket',
+        objectName: 'a/../b',
+      })
+    )
+    expect(response.status).toBe(200)
+
+    const segments = new URL(requestedUrl()).pathname.split('/').filter(Boolean)
+    expect(segments).toEqual(['storage', 'v1', 'b', 'vault-bucket', 'o', 'a%2F..%2Fb'])
+  })
+})

apps/sim/app/api/tools/google_vault/download-export-file/route.ts

@@ -16,6 +16,29 @@ export const dynamic = 'force-dynamic'
 
 const logger = createLogger('GoogleVaultDownloadExportFileAPI')
 
+/**
+ * Rejects a value that would collapse the URL path segment it occupies.
+ *
+ * This route deliberately keeps `encodeURIComponent` on the object name: a GCS
+ * object name legitimately contains `/`, and the JSON API addresses it as a
+ * single segment with those slashes as `%2F`, so the multi-segment
+ * `safeUrlPath` helper would misaddress the object. But encoding never
+ * neutralizes a dot segment — `.` and `..` are unreserved, so they survive
+ * encoding and the WHATWG parser removes the segment afterwards, turning
+ * `/b/{bucket}/o/..` into the object *list* endpoint with the caller's bearer
+ * token attached. Only rejection closes that, and only the whole value can do
+ * it: an interior `..` is encoded into the same segment and stays inert.
+ *
+ * The check trims before comparing but the caller still sends the untrimmed
+ * value, so no legitimate name is silently rewritten.
+ */
+function assertNotDotSegment(value: string, paramName: string): void {
+  const trimmed = value.trim()
+  if (trimmed === '.' || trimmed === '..') {
+    throw new Error(`${paramName} cannot be "${trimmed}" (path traversal is not allowed)`)
+  }
+}
+
 export const POST = withRouteHandler(async (request: NextRequest) => {
   const requestId = generateRequestId()
 
@@ -39,6 +62,15 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
 
     const { accessToken, bucketName, objectName, fileName } = validatedData
 
+    try {
+      assertNotDotSegment(bucketName, 'bucketName')
+      assertNotDotSegment(objectName, 'objectName')
+    } catch (error) {
+      const message = getErrorMessage(error, 'Invalid request')
+      logger.warn(`[${requestId}] Rejected unsafe Vault object path`, { error: message })
+      return NextResponse.json({ success: false, error: message }, { status: 400 })
+    }
+
     const bucket = encodeURIComponent(bucketName)
     const object = encodeURIComponent(objectName)
     const downloadUrl = `https://storage.googleapis.com/storage/v1/b/${bucket}/o/${object}?alt=media`

apps/sim/blocks/blocks/serper.ts

@@ -111,7 +111,7 @@ export const SerperBlock: BlockConfig<SearchResponse> = {
     searchResults: {
       type: 'json',
       description:
-        'Results for the requested vertical: [{title, link, snippet, position, date, imageUrl, thumbnailUrl, source, channel, rating, ratingCount, address, latitude, longitude, category, phoneNumber, website, price, delivery, duration}]. Only title and position are always present; the rest depend on the vertical'
+        'Results for the requested vertical: [{title, link, snippet, position, date, imageUrl, thumbnailUrl, source, channel, rating, ratingCount, address, latitude, longitude, category, phoneNumber, website, price, delivery, duration}]. Only title and position are always present; the rest depend on the vertical',
     },
     knowledgeGraph: {
       type: 'json',

apps/sim/tools/cloudflare/cloudflare.test.ts

@@ -998,6 +998,31 @@ describe('zone settings are read through the endpoints Cloudflare still supports
     expect(out.error).toBe('Invalid zone identifier')
   })
 
+  /**
+   * The zone id is guarded ONCE above the fan-out. Re-guarding it per setting
+   * raised the same error up to 40 times and filled `unreadable` with 40
+   * identical rows before the call failed.
+   */
+  it('reports a bad zone id once, with no requests and no unreadable rows', async () => {
+    const fetchMock = vi.spyOn(globalThis, 'fetch')
+
+    const out = (await tool.directExecution!({
+      zoneId: '..',
+      apiKey,
+      settingIds: Array.from({ length: 40 }, (_, index) => `setting_${index}`).join(','),
+    } as never)) as {
+      success: boolean
+      error?: string
+      output: { settings: unknown[]; unreadable: unknown[] }
+    }
+
+    expect(out.success).toBe(false)
+    expect(out.error).toMatch(/zoneId/)
+    expect(out.output.unreadable).toEqual([])
+    expect(out.output.settings).toEqual([])
+    expect(fetchMock).not.toHaveBeenCalled()
+  })
+
   it('refuses an unbounded fan-out instead of issuing the requests', async () => {
     const fetchMock = vi.spyOn(globalThis, 'fetch')
 

apps/sim/tools/cloudflare/get_zone_settings.ts

@@ -15,9 +15,16 @@ import {
 import type { ToolConfig } from '@/tools/types'
 import { safeUrlPathSegment } from '@/tools/url-path'
 
-/** Builds the per-setting endpoint Cloudflare directs integrations at. */
-function zoneSettingUrl(zoneId: string, settingId: string): string {
-  return `https://api.cloudflare.com/client/v4/zones/${safeUrlPathSegment(zoneId, 'zoneId')}/settings/${safeUrlPathSegment(settingId, 'settingIds')}`
+/**
+ * Builds the per-setting endpoint Cloudflare directs integrations at.
+ *
+ * `zoneId` arrives already guarded — see {@link zoneSettingUrl}'s caller in
+ * `directExecution`, which validates it once above the fan-out. Re-guarding it inside the fan-out
+ * would raise the same error once per requested setting, turning one bad zone id into up to
+ * {@link MAX_ZONE_SETTING_IDS} identical `unreadable` rows before the call failed.
+ */
+function zoneSettingUrl(guardedZoneId: string, settingId: string): string {
+  return `https://api.cloudflare.com/client/v4/zones/${guardedZoneId}/settings/${safeUrlPathSegment(settingId, 'settingIds')}`
 }
 
 /**
@@ -69,7 +76,11 @@ export const getZoneSettingsTool: ToolConfig<
   },
 
   request: {
-    url: (params) => zoneSettingUrl(params.zoneId, requestedZoneSettingIds(params.settingIds)[0]),
+    url: (params) =>
+      zoneSettingUrl(
+        safeUrlPathSegment(params.zoneId, 'zoneId'),
+        requestedZoneSettingIds(params.settingIds)[0]
+      ),
     method: 'GET',
     headers: (params) => cloudflareHeaders(params.apiKey),
   },
@@ -96,7 +107,17 @@ export const getZoneSettingsTool: ToolConfig<
       }
     }
 
-    const zoneId = params.zoneId
+    let zoneId: string
+    try {
+      zoneId = safeUrlPathSegment(params.zoneId, 'zoneId')
+    } catch (error) {
+      return {
+        success: false,
+        output: { settings: [], unreadable: [] },
+        error: getErrorMessage(error, 'Invalid zoneId'),
+      }
+    }
+
     const headers = cloudflareHeaders(params.apiKey)
 
     const reads = await Promise.all(