fix(credentials): report a refused host as the user's input, persist normalized account ids, cap Databricks reads

- A saved-credential check whose typed host the egress policy refuses (private address, plain http where https is required) now fails as invalid_credentials instead of provider_unavailable, which rendered as a retryable 503
- The stored account id is the validator's normalized value, matching how the domain is stored
- Databricks token and identity responses are read through the capped JSON reader
- Comparison data no longer says Sim can be built in code via an SDK

Author: waleedlatif1

apps/sim/lib/compare/data/sim.ts

@@ -134,14 +134,14 @@ export const simProfile: CompetitorProfile = {
   facts: {
     platform: {
       builderType: {
-        value: 'Visual drag-and-drop canvas, natural-language (Chat), or code (API/SDK)',
+        value: 'Visual drag-and-drop canvas, natural-language (Chat), or code (REST API and CLI)',
         shortValue: 'Visual canvas, chat, or code',
         confidence: 'verified',
         sources: [
           {
             url: 'https://docs.sim.ai/introduction',
-            label: 'Sim Docs: Introduction (visual, natural-language, and API/SDK building)',
-            asOf: '2026-07-08',
+            label: 'Sim Docs: Introduction (visual, natural-language, and API building)',
+            asOf: '2026-11-10',
           },
         ],
       },
@@ -155,8 +155,8 @@ export const simProfile: CompetitorProfile = {
         sources: [
           {
             url: 'https://docs.sim.ai/introduction',
-            label: 'Sim Docs: Introduction (visual, natural-language, and API/SDK building)',
-            asOf: '2026-07-08',
+            label: 'Sim Docs: Introduction (visual, natural-language, and API building)',
+            asOf: '2026-11-10',
           },
         ],
       },

apps/sim/lib/credentials/databricks-service-account.server.ts

@@ -5,6 +5,7 @@ import { eq } from 'drizzle-orm'
 import { z } from 'zod'
 import { decryptSecret, encryptSecret } from '@/lib/core/security/encryption'
 import { validateDatabricksWorkspaceHost } from '@/lib/core/security/input-validation'
+import { readResponseJsonWithLimit } from '@/lib/core/utils/stream-limits'
 import { parseServiceAccountConfig } from '@/lib/credentials/service-account-config'
 import {
   providerFailureCode,
@@ -42,6 +43,8 @@ const DATABRICKS_CREDENTIAL_SECRET_TYPE = 'databricks_credential_v1' as const
 const DATABRICKS_WORKLOAD_IDENTITY_AUDIENCE = WORKLOAD_IDENTITY_AUDIENCES.databricks
 
 const REQUEST_TIMEOUT_MS = 15_000
+/** Token and identity responses are small; the cap keeps a misbehaving host from exhausting memory. */
+const MAX_RESPONSE_BYTES = 1024 * 1024
 const CLIENT_ID_PATTERN = /^[A-Za-z0-9-]{8,128}$/
 
 /** Workspace origin with Databricks' own host allowlist as the SSRF guard. */
@@ -143,7 +146,10 @@ async function requestWorkspaceToken(
     redirect: 'error',
     signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
   })
-  const payload = (await response.json().catch(() => ({}))) as {
+  const payload = (await readResponseJsonWithLimit(response, {
+    maxBytes: MAX_RESPONSE_BYTES,
+    label: 'Databricks token response',
+  }).catch(() => ({}))) as {
     access_token?: unknown
     error_description?: unknown
     error?: unknown
@@ -240,7 +246,10 @@ async function verifyWorkspaceIdentity(
       signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
     })
     if (!response.ok) throw new Error(`workspace returned HTTP ${response.status}`)
-    const me = (await response.json().catch(() => ({}))) as {
+    const me = (await readResponseJsonWithLimit(response, {
+      maxBytes: MAX_RESPONSE_BYTES,
+      label: 'Databricks identity response',
+    }).catch(() => ({}))) as {
       userName?: unknown
       displayName?: unknown
     }

apps/sim/lib/credentials/service-account-secret.ts

@@ -388,7 +388,9 @@ async function buildTokenServiceAccountSecret(
     providerId,
     apiToken,
     ...(requiresDomain ? { domain: validation.normalizedDomain ?? domain } : {}),
-    ...(requiresWorkspace ? { providerWorkspaceId } : {}),
+    ...(requiresWorkspace
+      ? { providerWorkspaceId: validation.normalizedWorkspaceId ?? providerWorkspaceId }
+      : {}),
     metadata: { ...validation.storedMetadata, ...principalMetadata },
   }
   const { encrypted } = await encryptSecret(JSON.stringify(blob))

apps/sim/lib/credentials/token-service-accounts/server.ts

@@ -271,6 +271,8 @@ export interface TokenServiceAccountValidationResult {
   storedMetadata?: Record<string, string>
   /** Normalized domain to persist instead of the raw user input (when collected). */
   normalizedDomain?: string
+  /** Normalized account id to persist instead of the raw user input (when collected). */
+  normalizedWorkspaceId?: string
 }
 
 export type TokenServiceAccountValidator = (

apps/sim/lib/credentials/token-service-accounts/validators/gitlab.test.ts

@@ -15,10 +15,16 @@ import { validateGitLabServiceAccount } from '@/lib/credentials/token-service-ac
 const activeToken = { name: 'sim-workflows', active: true, revoked: false, scopes: ['api'] }
 
 describe('GitLab saved token verification', () => {
-  const fetch = inputValidationMockFns.mockSecureFetchWithValidation
+  const fetch = inputValidationMockFns.mockSecureFetchWithPinnedIP
+  const validateUrl = inputValidationMockFns.mockValidateUrlWithDNS
 
   beforeEach(() => {
     fetch.mockReset()
+    validateUrl.mockReset().mockResolvedValue({
+      isValid: true,
+      resolvedIP: '203.0.113.7',
+      originalHostname: 'gitlab.example.com',
+    })
   })
 
   it('verifies the token at the host it was typed with and stores that host', async () => {
@@ -33,6 +39,7 @@ describe('GitLab saved token verification', () => {
     })
     expect(fetch).toHaveBeenCalledWith(
       'https://gitlab.example.com/api/v4/personal_access_tokens/self',
+      '203.0.113.7',
       expect.objectContaining({ maxRedirects: 0, profile: 'configuredEndpoint' })
     )
   })
@@ -67,11 +74,11 @@ describe('GitLab saved token verification', () => {
   })
 
   it('reports a host that does not exist as not found, so the user fixes it instead of retrying', async () => {
-    fetch.mockRejectedValue(
-      new Error('url hostname could not be resolved', {
-        cause: Object.assign(new Error('getaddrinfo ENOTFOUND'), { code: 'ENOTFOUND' }),
-      })
-    )
+    validateUrl.mockResolvedValue({
+      isValid: false,
+      error: 'url hostname could not be resolved',
+      cause: Object.assign(new Error('getaddrinfo ENOTFOUND'), { code: 'ENOTFOUND' }),
+    })
 
     await expect(
       validateGitLabServiceAccount({ apiToken: 'glpat-x', domain: 'gitlab.exmaple.com' })

apps/sim/lib/credentials/token-service-accounts/validators/http.test.ts

@@ -128,7 +128,8 @@ describe('tokenCheckValidator', () => {
 })
 
 describe('tokenCheckValidator with a typed host', () => {
-  const secureFetch = inputValidationMockFns.mockSecureFetchWithValidation
+  const validateUrl = inputValidationMockFns.mockValidateUrlWithDNS
+  const pinnedFetch = inputValidationMockFns.mockSecureFetchWithPinnedIP
   const validateHost = tokenCheckValidator({
     serviceLabel: 'Example',
     domain: ({ domain }) => {
@@ -144,17 +145,30 @@ describe('tokenCheckValidator with a typed host', () => {
   })
 
   beforeEach(() => {
-    secureFetch.mockReset()
+    validateUrl.mockReset()
+    validateUrl.mockResolvedValue({
+      isValid: true,
+      resolvedIP: '203.0.113.7',
+      originalHostname: 'tools.example.com',
+    })
+    pinnedFetch.mockReset()
   })
 
   it('verifies at the normalized host through the guarded egress and stores that host', async () => {
-    secureFetch.mockResolvedValue(jsonResponse({ ok: true }))
+    pinnedFetch.mockResolvedValue(jsonResponse({ ok: true }))
 
     await expect(
       validateHost({ apiToken: 'good', domain: ' Tools.Example.com ' })
     ).resolves.toMatchObject({ normalizedDomain: 'tools.example.com' })
-    expect(secureFetch).toHaveBeenCalledWith(
+    expect(validateUrl).toHaveBeenCalledWith(
+      'https://tools.example.com/api/me',
+      'url',
+      'configuredEndpoint',
+      expect.anything()
+    )
+    expect(pinnedFetch).toHaveBeenCalledWith(
       'https://tools.example.com/api/me',
+      '203.0.113.7',
       expect.objectContaining({ profile: 'configuredEndpoint', maxRedirects: 0 })
     )
   })
@@ -170,22 +184,41 @@ describe('tokenCheckValidator with a typed host', () => {
     await expect(
       validateHost({ apiToken: 'good', domain: 'evil.example.com@tools.example.com' })
     ).rejects.toMatchObject({ code: 'invalid_credentials' })
-    expect(secureFetch).not.toHaveBeenCalled()
+    expect(validateUrl).not.toHaveBeenCalled()
+    expect(pinnedFetch).not.toHaveBeenCalled()
+  })
+
+  it('reports a host the egress policy refuses as the user input, not a retryable outage', async () => {
+    validateUrl.mockResolvedValue({ isValid: false, error: 'url resolves to a private address' })
+
+    await expect(
+      validateHost({ apiToken: 'good', domain: 'grafana.internal' })
+    ).rejects.toMatchObject({ code: 'invalid_credentials', status: 400 })
+    expect(pinnedFetch).not.toHaveBeenCalled()
+  })
+
+  it('reports a host that cannot be reached as the provider being unavailable', async () => {
+    pinnedFetch.mockRejectedValue(new Error('connect ECONNREFUSED'))
+
+    await expect(
+      validateHost({ apiToken: 'good', domain: 'tools.example.com' })
+    ).rejects.toMatchObject({ code: 'provider_unavailable', status: 502 })
   })
 
   it.each([
     [
       'Node (code on cause)',
-      new Error('fetch failed', {
+      new Error('lookup failed', {
         cause: Object.assign(new Error('getaddrinfo ENOTFOUND'), { code: 'ENOTFOUND' }),
       }),
     ],
-    [
-      'Bun (code on the error)',
-      Object.assign(new TypeError('fetch failed'), { code: 'ENOTFOUND' }),
-    ],
-  ])('reports a host that does not exist as not found under %s', async (_runtime, error) => {
-    secureFetch.mockRejectedValue(error)
+    ['Bun (code on the error)', Object.assign(new Error('lookup failed'), { code: 'ENOTFOUND' })],
+  ])('reports a host that does not exist as not found under %s', async (_runtime, cause) => {
+    validateUrl.mockResolvedValue({
+      isValid: false,
+      error: 'url hostname could not be resolved',
+      cause,
+    })
 
     await expect(
       validateHost({ apiToken: 'good', domain: 'tools.exmaple.com' })

apps/sim/lib/credentials/token-service-accounts/validators/http.ts

@@ -1,6 +1,9 @@
 import { truncate } from '@sim/utils/string'
 import type { EgressProfile } from '@/lib/core/security/egress/profiles'
-import { secureFetchWithValidation } from '@/lib/core/security/input-validation.server'
+import {
+  secureFetchWithPinnedIP,
+  validateUrlWithDNS,
+} from '@/lib/core/security/input-validation.server'
 import { readResponseJsonWithLimit } from '@/lib/core/utils/stream-limits'
 import {
   fetchProvider,
@@ -153,13 +156,34 @@ function normalizedField(
   }
 }
 
-/** Sends a check through the guarded egress profile, mapping a host that doesn't exist to `site_not_found`. */
+/**
+ * Sends a check through the guarded egress profile. A host the policy refuses
+ * (a private address, or plain http where https is required) is the user's
+ * input, so it fails as `invalid_credentials` rather than `provider_unavailable`,
+ * which renders as a retryable 503. A host that doesn't exist is `site_not_found`.
+ */
 async function sendThroughEgress(
   profile: NonNullable<TokenCheck['egress']>,
   { url, method = 'GET', headers, body }: TokenCheckRequest
 ): Promise<ProviderResponse> {
+  const validation = await validateUrlWithDNS(url, 'url', profile, { logDetails: false })
+  if (!validation.isValid) {
+    // Only a failed DNS lookup carries a cause; without one the policy refused the host.
+    if (validation.cause === undefined) {
+      throw new TokenServiceAccountValidationError('invalid_credentials', 400, {
+        step: 'verify',
+        reason: 'host not allowed',
+      })
+    }
+    const notFound = isHostNotFound(validation.cause)
+    throw new TokenServiceAccountValidationError(
+      notFound ? 'site_not_found' : 'provider_unavailable',
+      notFound ? 400 : 502,
+      { step: 'verify', reason: notFound ? 'host does not resolve' : 'host lookup failed' }
+    )
+  }
   try {
-    return await secureFetchWithValidation(url, {
+    return await secureFetchWithPinnedIP(url, validation.resolvedIP, {
       profile,
       method,
       headers,
@@ -169,13 +193,11 @@ async function sendThroughEgress(
       maxResponseBytes: MAX_EGRESS_RESPONSE_BYTES,
       logUrlValidationDetails: false,
     })
-  } catch (error) {
-    const notFound = isHostNotFound(error)
-    throw new TokenServiceAccountValidationError(
-      notFound ? 'site_not_found' : 'provider_unavailable',
-      notFound ? 400 : 502,
-      { step: 'verify', reason: notFound ? 'host does not resolve' : 'host unreachable' }
-    )
+  } catch {
+    throw new TokenServiceAccountValidationError('provider_unavailable', 502, {
+      step: 'verify',
+      reason: 'host unreachable',
+    })
   }
 }
 
@@ -203,6 +225,7 @@ export function tokenCheckValidator(check: TokenCheck): TokenServiceAccountValid
         ...(workspaceId === undefined ? {} : { accountId: workspaceId }),
       },
       ...(domain === undefined ? {} : { normalizedDomain: domain }),
+      ...(workspaceId === undefined ? {} : { normalizedWorkspaceId: workspaceId }),
     }
     const request = check.request(fields)
     const response: ProviderResponse = check.egress

apps/sim/lib/credentials/token-service-accounts/validators/token-checks.test.ts

@@ -385,30 +385,30 @@ describe('saved credentials for a host the user chose', () => {
   it.each(HOST_CHOSEN_VALIDATORS)(
     '%s refuses credentials smuggled into the URL before sending the key anywhere',
     async (_, validate) => {
-      inputValidationMockFns.mockSecureFetchWithValidation.mockReset()
+      inputValidationMockFns.mockSecureFetchWithPinnedIP.mockReset()
 
       await expect(
         validate({ apiToken: 'secret', domain: 'https://user:pass@instance.example.com' })
       ).rejects.toMatchObject({ code: 'invalid_credentials' })
-      expect(inputValidationMockFns.mockSecureFetchWithValidation).not.toHaveBeenCalled()
+      expect(inputValidationMockFns.mockSecureFetchWithPinnedIP).not.toHaveBeenCalled()
     }
   )
 
   it.each(HOST_CHOSEN_VALIDATORS)(
     '%s refuses a non-http scheme instead of reading it as a host',
     async (_, validate) => {
-      inputValidationMockFns.mockSecureFetchWithValidation.mockReset()
+      inputValidationMockFns.mockSecureFetchWithPinnedIP.mockReset()
 
       await expect(
         validate({ apiToken: 'secret', domain: 'ftp://instance.example.com' })
       ).rejects.toMatchObject({ code: 'invalid_credentials' })
-      expect(inputValidationMockFns.mockSecureFetchWithValidation).not.toHaveBeenCalled()
+      expect(inputValidationMockFns.mockSecureFetchWithPinnedIP).not.toHaveBeenCalled()
     }
   )
 })
 
 describe('saved credentials whose vendor answers a restricted token in its error', () => {
-  const secureFetch = inputValidationMockFns.mockSecureFetchWithValidation
+  const secureFetch = inputValidationMockFns.mockSecureFetchWithPinnedIP
 
   it.each([
     [
@@ -436,6 +436,11 @@ describe('saved credentials whose vendor answers a restricted token in its error
       'invalid_credentials',
     ],
   ])('%s', async (_, validate, reply, code) => {
+    inputValidationMockFns.mockValidateUrlWithDNS.mockReset().mockResolvedValue({
+      isValid: true,
+      resolvedIP: '203.0.113.7',
+      originalHostname: 'instance.example.com',
+    })
     secureFetch.mockReset().mockResolvedValue(reply)
 
     const result = validate({ apiToken: 'tok', domain: 'https://instance.example.com' })