fix(credentials): report a refused connection host as host_not_allowed

- egress validation names its refusal (dns or policy) instead of callers
  inferring it from a missing cause; an empty DNS answer is ENOTFOUND
- the token check judges every DNS record when an environment proxy will
  carry the request, so a mixed public/private host is refused up front
  rather than failing in the transport as a retryable 502; the transport's
  own refusal is a typed EgressRefusedError and maps the same way
- new host_not_allowed code (400) with its own connect-modal message
- Flow and GitLab personal-token verification classify a refused or
  missing host the same way
- the typed-URL scheme guard is shared and ignores the tabs and newlines
  the URL parser drops

Author: waleedlatif1

apps/sim/lib/core/network/transport.server.ts

@@ -6,6 +6,14 @@ import { OutboundRoutingError } from '@/lib/core/network/routing'
 import type { EgressProfile } from '@/lib/core/security/egress/profiles'
 import { validateEgressUrl } from '@/lib/core/security/egress/validate'
 
+/** The egress policy refused a destination the transport was asked to reach through a proxy. */
+export class EgressRefusedError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'EgressRefusedError'
+  }
+}
+
 interface OutboundTransportOptions {
   profile: EgressProfile
   resolvedIP?: string
@@ -58,7 +66,10 @@ export function createOutboundTransport(options: OutboundTransportOptions): Outb
       signal,
       requireEveryAddress: true,
     })
-    if (!validation.isValid) throw new Error(validation.error, { cause: validation.cause })
+    if (!validation.isValid) {
+      if (validation.refusal === 'policy') throw new EgressRefusedError(validation.error)
+      throw new Error(validation.error, { cause: validation.cause })
+    }
     if (closed) throw new OutboundRoutingError('GATEWAY_UNAVAILABLE')
     let agent = environmentProxies.get(proxyUrl)
     if (!agent) {

apps/sim/lib/core/security/egress/validate.ts

@@ -35,9 +35,13 @@ export interface EgressValidationSuccess {
   readonly originalHostname: string
 }
 
+/** Why a destination failed: its name could not be resolved, or the policy refused it. */
+export type EgressRefusal = 'dns' | 'policy'
+
 export interface EgressValidationFailure {
   readonly isValid: false
   readonly error: string
+  readonly refusal: EgressRefusal
   /** Retains resolver failure codes so callers can distinguish an outage from a policy denial. */
   readonly cause?: unknown
 }
@@ -67,7 +71,11 @@ function fail(
       ? { profile, reason: decision.reason, paramName }
       : { profile, reason: decision.reason, detail: decision.detail, paramName }
   )
-  return { isValid: false, error: describeEgressDenial(decision, paramName, profile) }
+  return {
+    isValid: false,
+    error: describeEgressDenial(decision, paramName, profile),
+    refusal: 'policy',
+  }
 }
 
 /**
@@ -85,14 +93,18 @@ export async function validateEgressUrl(
 ): Promise<EgressValidationResult> {
   options.signal?.throwIfAborted()
   if (!url || typeof url !== 'string') {
-    return { isValid: false, error: `${paramName} is required and must be a string` }
+    return {
+      isValid: false,
+      error: `${paramName} is required and must be a string`,
+      refusal: 'policy',
+    }
   }
 
   let parsed: URL
   try {
     parsed = new URL(url)
   } catch {
-    return { isValid: false, error: `${paramName} must be a valid URL` }
+    return { isValid: false, error: `${paramName} must be a valid URL`, refusal: 'policy' }
   }
 
   const policy = resolveEgressPolicy(profile)
@@ -129,7 +141,12 @@ export async function validateEgressUrl(
         ? { profile, paramName }
         : { profile, paramName, host, error: toError(error).message }
     )
-    return { isValid: false, error: `${paramName} hostname could not be resolved`, cause: error }
+    return {
+      isValid: false,
+      error: `${paramName} hostname could not be resolved`,
+      cause: error,
+      refusal: 'dns',
+    }
   }
 
   // Refused records are filtered rather than failing the whole host: pinning to a

apps/sim/lib/core/security/input-validation.server.test.ts

@@ -11,6 +11,7 @@ vi.mock('@sim/security/dns', () => ({
     addresses.find((address) => address.includes('.')) ?? addresses[0],
 }))
 
+import { EgressRefusedError } from '@/lib/core/network/transport.server'
 import {
   secureFetchWithValidation,
   validateUrlWithDNS,
@@ -122,6 +123,13 @@ describe('validateUrlWithDNS address classification', () => {
     ).rejects.toMatchObject({ message: 'url hostname could not be resolved', cause })
   })
 
+  it('throws a policy refusal as an egress refusal, distinct from a lookup failure', async () => {
+    mockResolve.mockResolvedValue(resolved(['10.0.0.5']))
+    await expect(
+      secureFetchWithValidation('https://internal.example/api', { profile: 'configuredEndpoint' })
+    ).rejects.toBeInstanceOf(EgressRefusedError)
+  })
+
   it('can conceal credential-derived host details in validation logs', async () => {
     mockResolve.mockRejectedValue(new Error('DNS failure with credential-host-canary'))
 

apps/sim/lib/core/security/input-validation.server.ts

@@ -20,12 +20,14 @@ import {
 import { OutboundRoutingError } from '@/lib/core/network/routing'
 import {
   createOutboundTransport,
+  EgressRefusedError,
   requestWithOutboundDispatcher,
 } from '@/lib/core/network/transport.server'
 import { describeEgressDenial, type EgressProfile } from '@/lib/core/security/egress/profiles'
 import {
   checkEgressUrl,
   checkResolvedEgress,
+  type EgressRefusal,
   type EgressValidationOptions,
   validateEgressUrl,
 } from '@/lib/core/security/egress/validate'
@@ -48,6 +50,8 @@ export type AsyncValidationResult =
       isValid: false
       error: string
       cause?: unknown
+      /** Set by {@link validateUrlWithDNS}: a failed lookup, or a destination the policy refused. */
+      refusal?: EgressRefusal
       resolvedIP?: undefined
       originalHostname?: undefined
     }
@@ -74,7 +78,7 @@ export async function validateUrlWithDNS(
   const result = await validateEgressUrl(url, paramName, profile, options)
   return result.isValid
     ? { isValid: true, resolvedIP: result.resolvedIP, originalHostname: result.originalHostname }
-    : { isValid: false, error: result.error, cause: result.cause }
+    : { isValid: false, error: result.error, cause: result.cause, refusal: result.refusal }
 }
 
 /**
@@ -1582,7 +1586,7 @@ export async function secureFetchWithPinnedIP(
  * @param options - Fetch options, including the required egress `profile`
  * @param paramName - Name of the parameter for error messages (default: 'url')
  * @returns SecureFetchResponse
- * @throws Error if URL validation fails
+ * @throws EgressRefusedError if the egress policy refuses the URL, Error if its host cannot be resolved
  */
 export async function secureFetchWithValidation(
   url: string,
@@ -1594,6 +1598,7 @@ export async function secureFetchWithValidation(
     signal: options.signal,
   })
   if (!validation.isValid) {
+    if (validation.refusal === 'policy') throw new EgressRefusedError(validation.error)
     throw new Error(validation.error, { cause: validation.cause })
   }
   return secureFetchWithPinnedIP(url, validation.resolvedIP, options)

apps/sim/lib/credentials/gitlab-personal-token.test.ts

@@ -8,6 +8,7 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 vi.mock('@/lib/core/security/input-validation.server', () => inputValidationMock)
 vi.mock('@/lib/core/security/encryption', () => encryptionMock)
 
+import { EgressRefusedError } from '@/lib/core/network/transport.server'
 import {
   decryptPersonalToken,
   encryptPersonalToken,
@@ -96,6 +97,15 @@ describe('GitLab personal token verification', () => {
     await expect(verifyGitLabPersonalToken('secret')).rejects.toThrow('GitLab rejected this token')
     expect(mocks.fetch).toHaveBeenCalledTimes(1)
   })
+  it('reports a host the egress policy refuses as the user input', async () => {
+    mocks.fetch
+      .mockReset()
+      .mockRejectedValue(new EgressRefusedError('url resolves to a private address'))
+    await expect(verifyGitLabPersonalToken('secret', 'gitlab.internal')).rejects.toMatchObject({
+      code: 'validation',
+      message: expect.stringContaining("can't connect to that address"),
+    })
+  })
   it('binds organization tokens independently of the execution workspace', async () => {
     mocks.encrypt.mockResolvedValue({ encrypted: 'ciphertext' })
     const { workspaceId: _workspaceId, ...identity } = envelope

apps/sim/lib/credentials/gitlab-personal-token.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod'
+import { EgressRefusedError } from '@/lib/core/network/transport.server'
 import { OrchestrationError } from '@/lib/core/orchestration/types'
 import { resourceScopeFromOwner, sameResourceScope } from '@/lib/core/resource-scope'
 import { decryptSecret, encryptSecret } from '@/lib/core/security/encryption'
@@ -55,6 +56,14 @@ export async function verifyGitLabPersonalToken(accessToken: string, rawHost?: s
       timeout: 10_000,
       maxResponseBytes: 64 * 1024,
       maxRedirects: 0,
+    }).catch((error: unknown) => {
+      if (error instanceof EgressRefusedError) {
+        throw new OrchestrationError(
+          'validation',
+          "Sim can't connect to that address. Use your GitLab instance's public https URL."
+        )
+      }
+      throw error
     })
     if (!response.ok) {
       throw new OrchestrationError(

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

@@ -2338,6 +2338,8 @@ export function getTokenServiceAccountErrorMessage(
       )
     case 'site_not_found':
       return "We couldn't find an account at that domain. Check the spelling and try again."
+    case 'host_not_allowed':
+      return "Sim can't connect to that address. Use the service's public https URL."
     case 'provider_unavailable':
       return `We couldn't reach ${descriptor.serviceLabel} to verify these credentials. Try again in a moment.`
     case 'duplicate_display_name':

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

@@ -14,6 +14,8 @@ export type TokenServiceAccountValidationCode =
   | 'invalid_credentials'
   | 'permission_conflict'
   | 'site_not_found'
+  /** The egress policy refused the typed host (a private address, or plain http). */
+  | 'host_not_allowed'
   | 'provider_unavailable'
 
 export class TokenServiceAccountValidationError extends Error {

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

@@ -0,0 +1,38 @@
+import {
+  inputValidationMock,
+  inputValidationMockFns,
+} from '@sim/testing/mocks/input-validation.mock'
+import { describe, expect, it, vi } from 'vitest'
+
+vi.mock('@/lib/core/security/input-validation.server', () => inputValidationMock)
+
+import { EgressRefusedError } from '@/lib/core/network/transport.server'
+import { validateFlowServiceAccount } from '@/lib/credentials/token-service-accounts/validators/flow'
+
+const fields = { apiToken: 'tok', domain: 'flow.internal', providerWorkspaceId: 'ws-1' }
+
+describe('validateFlowServiceAccount', () => {
+  it('reports a host the egress policy refuses as the user input, not a retryable outage', async () => {
+    inputValidationMockFns.mockSecureFetchWithValidation.mockRejectedValue(
+      new EgressRefusedError('url resolves to a private address')
+    )
+
+    await expect(validateFlowServiceAccount(fields)).rejects.toMatchObject({
+      code: 'host_not_allowed',
+      status: 400,
+    })
+  })
+
+  it('reports a host that does not exist as not found', async () => {
+    inputValidationMockFns.mockSecureFetchWithValidation.mockRejectedValue(
+      new Error('url hostname could not be resolved', {
+        cause: Object.assign(new Error('getaddrinfo ENOTFOUND'), { code: 'ENOTFOUND' }),
+      })
+    )
+
+    await expect(validateFlowServiceAccount(fields)).rejects.toMatchObject({
+      code: 'site_not_found',
+      status: 400,
+    })
+  })
+})

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

@@ -1,7 +1,9 @@
 import { toRecord } from '@sim/utils/object'
+import { EgressRefusedError } from '@/lib/core/network/transport.server'
 import { secureFetchWithValidation } from '@/lib/core/security/input-validation.server'
 import { userPrincipal } from '@/lib/credentials/principal'
 import {
+  isHostNotFound,
   isTransientProviderStatus,
   TokenServiceAccountValidationError,
 } from '@/lib/credentials/token-service-accounts/errors'
@@ -60,6 +62,13 @@ export async function validateFlowServiceAccount(
     }
   } catch (error) {
     if (error instanceof TokenServiceAccountValidationError) throw error
+    // A host the egress policy refuses, or one that doesn't exist, is the user's input.
+    if (error instanceof EgressRefusedError) {
+      throw new TokenServiceAccountValidationError('host_not_allowed', 400)
+    }
+    if (error instanceof Error && isHostNotFound(error.cause)) {
+      throw new TokenServiceAccountValidationError('site_not_found', 400)
+    }
     throw new TokenServiceAccountValidationError('provider_unavailable', 502)
   }
 }