fix(oracle-epm): address follow-up review findings

Author: Bill Leoutsakos

apps/sim/lib/credentials/client-credential-accounts/minters/oracle-epm.test.ts

@@ -33,6 +33,8 @@ describe('mintOracleEpmServiceAccountToken', () => {
     { clientId: 'user:name', clientSecret: 'password' },
     { clientId: 'user\nname', clientSecret: 'password' },
     { clientId: 'user', clientSecret: 'pass\nword' },
+    { clientId: 'user\uD800', clientSecret: 'password' },
+    { clientId: 'user', clientSecret: 'password\uDC00' },
     { clientId: '', clientSecret: 'password' },
   ])('rejects unsafe Basic credential text', async (credentials) => {
     await expect(
@@ -43,6 +45,15 @@ describe('mintOracleEpmServiceAccountToken', () => {
     ).rejects.toBeInstanceOf(TokenServiceAccountValidationError)
   })
 
+  it('preserves valid surrogate pairs in Basic credential values', async () => {
+    const result = await mintOracleEpmServiceAccountToken({
+      orgId: 'https://epm.example.com',
+      clientId: 'integration-😀',
+      clientSecret: 'password-🔒',
+    })
+    expect(Buffer.from(result.accessToken, 'base64').toString()).toBe('integration-😀:password-🔒')
+  })
+
   it('does not reflect secrets in validation errors', async () => {
     const secret = 'password-with-newline\n'
     const error = await mintOracleEpmServiceAccountToken({

apps/sim/lib/credentials/client-credential-accounts/minters/oracle-epm.ts

@@ -13,6 +13,7 @@ const SYNTHETIC_TOKEN_TTL_SECONDS = 600
 const MAX_USERNAME_BYTES = 255
 const MAX_AUTH_VALUE_BYTES = 1_024
 const FORBIDDEN_CREDENTIAL_TEXT = /[\u0000-\u001f\u007f]/
+const MALFORMED_UTF16 = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/
 
 function invalidCredentials(reason: string): TokenServiceAccountValidationError {
   return new TokenServiceAccountValidationError('invalid_credentials', 400, {
@@ -49,13 +50,15 @@ export async function mintOracleEpmServiceAccountToken(
     !username ||
     username.includes(':') ||
     FORBIDDEN_CREDENTIAL_TEXT.test(username) ||
+    MALFORMED_UTF16.test(username) ||
     Buffer.byteLength(username, 'utf8') > MAX_USERNAME_BYTES
   ) {
     throw invalidCredentials('integration username is invalid')
   }
   if (
     !password ||
     FORBIDDEN_CREDENTIAL_TEXT.test(password) ||
+    MALFORMED_UTF16.test(password) ||
     Buffer.byteLength(password, 'utf8') > MAX_AUTH_VALUE_BYTES
   ) {
     throw invalidCredentials('password is invalid')

apps/sim/lib/internal/oracle-epm/client.server.test.ts

@@ -1,5 +1,6 @@
 /** @vitest-environment node */
 import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { PayloadSizeLimitError } from '@/lib/core/utils/stream-limits'
 
 const { mockSecureFetch, mockValidateUrl } = vi.hoisted(() => ({
   mockSecureFetch: vi.fn(),
@@ -93,7 +94,7 @@ describe('Oracle EPM guarded client', () => {
       { logDetails: false }
     )
     expect(mockSecureFetch).toHaveBeenCalledWith(
-      expect.any(String),
+      'https://epm.example.com/gateway/acme/SyntheticAlpha/rest/v3/jobs/job%20with%20spaces?limit=25',
       '203.0.113.10',
       expect.objectContaining({
         method: 'GET',
@@ -146,6 +147,50 @@ describe('Oracle EPM guarded client', () => {
     expect(mockValidateUrl).not.toHaveBeenCalled()
   })
 
+  it('preserves valid surrogate pairs in encoded path and query parameters', async () => {
+    const endpoint = routes.defineEndpoint({
+      method: 'GET',
+      version: 'v3',
+      path: [oracleEpmLiteral('files'), oracleEpmPathParameter('fileId', { maxBytes: 32 })],
+      query: { label: oracleEpmQuery.string({ maxBytes: 32 }) },
+      body: 'none',
+      response: 'json',
+      timeoutMs: 2_000,
+      maxResponseBytes: 1_024,
+    })
+    const client = createOracleEpmClient({
+      instanceUrl: 'https://epm.example.com',
+      accessToken: Buffer.from('u:p').toString('base64'),
+    })
+    await client.request(endpoint, {
+      pathParams: { fileId: 'report-😀' },
+      query: { label: 'locked-🔒' },
+    })
+    expect(mockSecureFetch.mock.calls[0][0]).toBe(
+      'https://epm.example.com/SyntheticAlpha/rest/v3/files/report-%F0%9F%98%80?label=locked-%F0%9F%94%92'
+    )
+  })
+
+  it('preserves streamed response size failures as payload-too-large errors', async () => {
+    mockSecureFetch.mockResolvedValue({
+      ...secureResponse({}),
+      json: vi.fn().mockRejectedValue(
+        new PayloadSizeLimitError({
+          label: 'secure fetch response',
+          maxBytes: 4_096,
+          observedBytes: 4_097,
+        })
+      ),
+    })
+    const client = createOracleEpmClient({
+      instanceUrl: 'https://epm.example.com',
+      accessToken: Buffer.from('u:p').toString('base64'),
+    })
+    await expect(client.request(getJob, { pathParams: { jobId: '42' } })).rejects.toMatchObject({
+      category: 'payload_too_large',
+    })
+  })
+
   it('suppresses arbitrary provider bodies in failed requests', async () => {
     mockSecureFetch.mockResolvedValue(
       secureResponse({
@@ -310,6 +355,8 @@ describe('Oracle EPM guarded client', () => {
     'https://epm.example.com/gateway/SyntheticAlpha/rest/v3/files/abc?token=x&token=y',
     'https://epm.example.com/gateway/SyntheticAlpha/rest/v3/files/abc?unknown=x',
     'https://epm.example.com/gateway/SyntheticAlpha/rest/v3/files/abc?token=x#fragment',
+    'https://epm.example.com/gateway/SyntheticAlpha/rest/v3/files/ab\nc?token=x',
+    'https://epm.example.com/gateway/SyntheticAlpha/rest/v3/files/\uD800?token=x',
   ])('rejects unsafe returned link %j', (href) => {
     const policy = routes.defineReturnedLinkPolicy({
       relation: 'download',

apps/sim/lib/internal/oracle-epm/client.server.ts

@@ -36,7 +36,8 @@ import type {
 } from '@/lib/internal/oracle-epm/types'
 
 const SAFE_TOKEN = /^[A-Za-z0-9+/]+={0,2}$/
-const LONE_SURROGATE = /[\uD800-\uDFFF]/
+const MALFORMED_UTF16 = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/
+const FORBIDDEN_LINK_TEXT = /[\u0000-\u001f\u007f]/
 const validatedLinks = new WeakMap<
   object,
   { owner: object; url: string; policy: OracleEpmReturnedLinkPolicyDefinition }
@@ -64,7 +65,7 @@ function validatePathValue(
     value === '.' ||
     value === '..' ||
     /[/\\\u0000-\u001f\u007f]/.test(value) ||
-    LONE_SURROGATE.test(value) ||
+    MALFORMED_UTF16.test(value) ||
     Buffer.byteLength(value, 'utf8') > declaration.maxBytes ||
     (declaration.pattern && !declaration.pattern.test(value))
   ) {
@@ -93,7 +94,7 @@ function serializeQueryValue(value: unknown, declaration: OracleEpmQueryParamete
   if (declaration.kind === 'string') {
     if (
       typeof value !== 'string' ||
-      LONE_SURROGATE.test(value) ||
+      MALFORMED_UTF16.test(value) ||
       Buffer.byteLength(value, 'utf8') > declaration.maxBytes ||
       (declaration.pattern && !declaration.pattern.test(value))
     )
@@ -152,7 +153,7 @@ function buildHeaders(
     }
     if (
       /\r|\n|\u0000/.test(value) ||
-      LONE_SURROGATE.test(value) ||
+      MALFORMED_UTF16.test(value) ||
       Buffer.byteLength(value, 'utf8') > declaration.maxBytes ||
       (declaration.pattern && !declaration.pattern.test(value))
     )
@@ -305,7 +306,8 @@ async function projectResponse(
   try {
     const data = await response.json()
     return Object.freeze({ status: response.status, data, correlationId })
-  } catch {
+  } catch (error) {
+    if (isPayloadSizeLimitError(error)) throw oracleEpmLocalError('payload_too_large')
     throw oracleEpmLocalError('invalid_response')
   }
 }
@@ -464,7 +466,9 @@ export function createOracleEpmClient(input: {
         link.rel !== policy.relation ||
         (link.method !== undefined && link.method !== policy.method) ||
         typeof link.href !== 'string' ||
-        link.href.length > 8_192
+        link.href.length > 8_192 ||
+        FORBIDDEN_LINK_TEXT.test(link.href) ||
+        MALFORMED_UTF16.test(link.href)
       )
         throw oracleEpmLocalError('invalid_input')
       let url: URL

apps/sim/lib/internal/oracle-epm/destination.test.ts

@@ -38,6 +38,8 @@ describe('Oracle EPM destination', () => {
     'https://epm.example.com/a%2Fb',
     'https:////epm.example.com/gateway',
     'https://epm.example.com/a\\b',
+    'https://epm.example.com/gateway/\uD800',
+    'https://epm.example.com/gateway/\uDC00',
   ])('rejects unsafe destination %j', (value) => {
     expect(() => defineOracleEpmDestination(value)).toThrow()
   })

apps/sim/lib/internal/oracle-epm/destination.ts

@@ -4,6 +4,7 @@ const MAX_DESTINATION_LENGTH = 2_048
 const MAX_PATH_SEGMENTS = 32
 const MAX_PATH_SEGMENT_BYTES = 255
 const FORBIDDEN_TEXT = /[\u0000-\u001f\u007f\\]/
+const MALFORMED_UTF16 = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/
 const destinations = new WeakMap<object, { origin: string; baseSegments: readonly string[] }>()
 
 function decodeSegment(segment: string): string {
@@ -33,6 +34,7 @@ function validateAndDecodeSegment(encoded: string): string {
     safetyValue === '..' ||
     safetyValue.includes('/') ||
     FORBIDDEN_TEXT.test(safetyValue) ||
+    MALFORMED_UTF16.test(decoded) ||
     Buffer.byteLength(decoded, 'utf8') > MAX_PATH_SEGMENT_BYTES
   ) {
     throw new Error('Oracle EPM environment URL base path is invalid')
@@ -43,7 +45,12 @@ function validateAndDecodeSegment(encoded: string): string {
 /** Validates and freezes the credential-bound Oracle EPM environment URL. */
 export function defineOracleEpmDestination(rawUrl: string): OracleEpmDestination {
   const value = rawUrl.trim()
-  if (!value || value.length > MAX_DESTINATION_LENGTH || FORBIDDEN_TEXT.test(value)) {
+  if (
+    !value ||
+    value.length > MAX_DESTINATION_LENGTH ||
+    FORBIDDEN_TEXT.test(value) ||
+    MALFORMED_UTF16.test(value)
+  ) {
     throw new Error('Oracle EPM environment URL is invalid')
   }
 

apps/sim/lib/internal/oracle-epm/files.server.test.ts

@@ -187,6 +187,74 @@ describe('Oracle EPM file primitives', () => {
     expect(destroy).toHaveBeenCalled()
   })
 
+  it('destroys a source canceled while its storage stream is opening', async () => {
+    let finishOpen: ((stream: Readable) => void) | undefined
+    mocks.downloadFileStream.mockReturnValue(
+      new Promise((resolve) => {
+        finishOpen = resolve
+      })
+    )
+    const controller = new AbortController()
+    const source = await openOracleEpmSourceFile({
+      file: {
+        id: 'f',
+        name: 'x',
+        url: '',
+        size: 0,
+        type: '',
+        key: 'workspace/key',
+        context: 'workspace',
+      },
+      userId: 'user-1',
+      maxBytes: 3,
+      signal: controller.signal,
+    })
+    const pending = (async () => {
+      for await (const _chunk of source.chunks) {
+        // Consume the guarded stream.
+      }
+    })()
+    await vi.waitFor(() => expect(mocks.downloadFileStream).toHaveBeenCalled())
+    controller.abort(new DOMException('user', 'AbortError'))
+    const stream = Readable.from([])
+    const destroy = vi.spyOn(stream, 'destroy')
+    finishOpen?.(stream)
+
+    await expect(pending).rejects.toMatchObject({ name: 'AbortError' })
+    expect(destroy).toHaveBeenCalled()
+  })
+
+  it('rejects a source canceled as an empty storage stream reaches EOF', async () => {
+    const controller = new AbortController()
+    const stream = new Readable({
+      read() {
+        this.push(null)
+        controller.abort(new DOMException('user', 'AbortError'))
+      },
+    })
+    mocks.downloadFileStream.mockResolvedValue(stream)
+    const source = await openOracleEpmSourceFile({
+      file: {
+        id: 'f',
+        name: 'x',
+        url: '',
+        size: 0,
+        type: '',
+        key: 'workspace/key',
+        context: 'workspace',
+      },
+      userId: 'user-1',
+      maxBytes: 3,
+      signal: controller.signal,
+    })
+
+    await expect(async () => {
+      for await (const _chunk of source.chunks) {
+        // Consume the guarded stream.
+      }
+    }).rejects.toMatchObject({ name: 'AbortError' })
+  })
+
   it('streams a bounded provider response into execution storage and returns UserFile', async () => {
     const body = new ReadableStream<Uint8Array>({
       start(controller) {

apps/sim/lib/internal/oracle-epm/files.server.ts

@@ -79,6 +79,7 @@ export async function openOracleEpmSourceFile(input: {
     const abort = () => stream.destroy(signal?.reason)
     signal?.addEventListener('abort', abort, { once: true })
     try {
+      signal?.throwIfAborted()
       for await (const chunk of stream) {
         signal?.throwIfAborted()
         const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk as Uint8Array)
@@ -92,6 +93,7 @@ export async function openOracleEpmSourceFile(input: {
         }
         yield buffer
       }
+      signal?.throwIfAborted()
     } finally {
       signal?.removeEventListener('abort', abort)
       stream.destroy()

apps/sim/lib/oauth/token-resolution.test.ts

@@ -492,6 +492,52 @@ describe('resolveCredentialAccessToken', () => {
     })
   })
 
+  it('preserves an existing service-account tool without OAuth service metadata', async () => {
+    mockResolveOAuthAccountId.mockResolvedValue({
+      accountId: 'credential-1',
+      credentialId: 'credential-1',
+      credentialType: 'service_account',
+      providerId: 'claude-platform-service-account',
+      usedCredentialTable: true,
+    })
+    mockGetToolMetadata.mockReturnValue({ oauth: undefined })
+    mockAuthorizeCredentialUseForAuth.mockResolvedValue({
+      ok: true,
+      requesterUserId: 'user-1',
+      credentialOwnerUserId: 'owner-1',
+      workspaceId: 'ws-1',
+      resolvedCredentialId: 'credential-1',
+    })
+    mockResolveServiceAccountToken.mockResolvedValue({ accessToken: 'workspace-api-key' })
+
+    await expect(
+      resolveCredentialAccessToken({
+        requestId: 'req-1',
+        credentialId: 'credential-1',
+        toolId: 'managed_agent_run_session',
+        authenticate,
+      })
+    ).resolves.toEqual({
+      ok: true,
+      token: {
+        accessToken: 'workspace-api-key',
+        credentialType: 'service_account',
+        apiDomain: undefined,
+        authStyle: undefined,
+        cloudId: undefined,
+        domain: undefined,
+        instanceUrl: undefined,
+      },
+    })
+    expect(mockGetServiceConfigByProviderId).not.toHaveBeenCalled()
+    expect(mockResolveServiceAccountToken).toHaveBeenCalledWith(
+      'credential-1',
+      'claude-platform-service-account',
+      [],
+      undefined
+    )
+  })
+
   it('rejects a mismatched OAuth account after loading its authoritative provider', async () => {
     mockResolveOAuthAccountId.mockResolvedValue({
       accountId: 'account-1',