fix(secrets): preserve own environment keys

Author: icecrasher321

apps/sim/app/api/function/execute/route.test.ts

@@ -935,6 +935,26 @@ describe('Function Execute API Route', () => {
       expect((await response.json()).__resolvedSecretNames).toEqual(['ALLOWED'])
     })
 
+    it('resolves a selected __proto__ secret as an own environment key', async () => {
+      const response = await POST(
+        createMockRequest(
+          'POST',
+          {
+            code: 'return "{{__proto__}}"',
+            envVars: Object.fromEntries([['__proto__', 'secret-value']]),
+            secretScope: 'selected',
+            mountedSecrets: ['__proto__'],
+          },
+          {
+            'x-sim-request-private-tool-metadata': 'resolved-secret-names-v1',
+          }
+        )
+      )
+
+      expect(response.status).toBe(200)
+      expect((await response.json()).__resolvedSecretNames).toEqual(['__proto__'])
+    })
+
     it.concurrent('should resolve tag variables with <tag_name> syntax', async () => {
       const req = createMockRequest('POST', {
         code: 'return <email>',

apps/sim/app/api/function/execute/route.ts

@@ -17,6 +17,7 @@ import {
   writeWorkspaceFileByPath,
 } from '@/lib/copilot/vfs/resource-writer'
 import { isRemoteSandboxEnabled } from '@/lib/core/config/env-flags'
+import { setRecordValue } from '@/lib/core/utils/records'
 import { generateRequestId } from '@/lib/core/utils/request'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
 import { executeInIsolatedVM, type IsolatedVMBrokerHandler } from '@/lib/execution/isolated-vm'
@@ -580,7 +581,7 @@ function scopeEnvironmentVariables(
   const scoped: Record<string, string> = {}
   const missing: string[] = []
   for (const name of allowed) {
-    if (name in envVars) scoped[name] = envVars[name]
+    if (Object.hasOwn(envVars, name)) setRecordValue(scoped, name, envVars[name])
     else missing.push(name)
   }
   if (missing.length > 0) {
@@ -608,19 +609,19 @@ function resolveEnvironmentVariables(
   const resolverVars: Record<string, string> = {}
   Object.entries(params).forEach(([key, value]) => {
     if (value !== undefined && value !== null) {
-      resolverVars[key] = String(value)
+      setRecordValue(resolverVars, key, String(value))
     }
   })
   Object.entries(envVars).forEach(([key, value]) => {
     if (value !== undefined && value !== null) {
-      resolverVars[key] = value
+      setRecordValue(resolverVars, key, value)
     }
   })
 
   while ((match = regex.exec(code)) !== null) {
     const varName = match[1].trim()
 
-    if (!(varName in resolverVars)) {
+    if (!Object.hasOwn(resolverVars, varName)) {
       continue
     }
 

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

@@ -1,5 +1,9 @@
 import { z } from 'zod'
-import { customPatternSchema, unknownRecordSchema } from '@/lib/api/contracts/primitives'
+import {
+  customPatternSchema,
+  stringRecordSchema,
+  unknownRecordSchema,
+} from '@/lib/api/contracts/primitives'
 import { defineRouteContract } from '@/lib/api/contracts/types'
 import { DEFAULT_CODE_LANGUAGE } from '@/lib/execution/languages'
 export const guardrailsValidateContract = defineRouteContract({
@@ -175,9 +179,9 @@ export const functionExecuteContract = defineRouteContract({
       })
       .strict()
       .optional(),
-    envVars: z.record(z.string(), z.string()).optional().default({}),
+    envVars: stringRecordSchema.optional().default({}),
     blockData: unknownRecordSchema.optional().default({}),
-    blockNameMapping: z.record(z.string(), z.string()).optional().default({}),
+    blockNameMapping: stringRecordSchema.optional().default({}),
     blockOutputSchemas: z.record(z.string(), unknownRecordSchema).optional().default({}),
     workflowVariables: unknownRecordSchema.optional().default({}),
     contextVariables: unknownRecordSchema.optional().default({}),

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

@@ -1,9 +1,25 @@
+import { isPlainRecord } from '@sim/utils/object'
 import { z } from 'zod'
+import { setRecordValue } from '@/lib/core/utils/records'
 import { PII_LANGUAGE_CODES, stripNerEntities } from '@/lib/guardrails/pii-entities'
 import { validateRegexPattern } from '@/lib/guardrails/validate_regex'
 
 export const unknownRecordSchema = z.record(z.string(), z.unknown())
 
+export const stringRecordSchema = z
+  .custom<Record<string, string>>(
+    (value) =>
+      isPlainRecord(value) && Object.values(value).every((entry) => typeof entry === 'string'),
+    { error: 'Expected a record of string values' }
+  )
+  .transform((value) => {
+    const record: Record<string, string> = {}
+    for (const [key, entry] of Object.entries(value)) {
+      setRecordValue(record, key, entry)
+    }
+    return record
+  })
+
 export function flattenFieldErrors<TFields extends string>(
   error: z.ZodError
 ): Partial<Record<TFields, string>> {

apps/sim/lib/copilot/tools/secret-mount-materializer.server.test.ts

@@ -112,6 +112,20 @@ describe('materializeCopilotCodeSecrets', () => {
     })
   })
 
+  it('mounts an own __proto__ secret as data without mutating record prototypes', async () => {
+    queueSources({ personal: Object.fromEntries([['__proto__', 'personal-cipher']]) })
+
+    const result = await materializeCopilotCodeSecrets({
+      actorUserId: 'user-1',
+      workspaceId: 'workspace-1',
+      requestedNames: ['__proto__'],
+    })
+
+    expect(Object.hasOwn(result.envVars, '__proto__')).toBe(true)
+    expect(result.envVars.__proto__).toBe('plain:personal-cipher')
+    expect(Object.getPrototypeOf(result.envVars)).toBe(Object.prototype)
+  })
+
   it('casts stored JSON values before using JSONB operators', async () => {
     queueSources({ personal: { API_KEY: 'personal-cipher' } })
 

apps/sim/lib/copilot/tools/secret-mount-materializer.server.ts

@@ -7,6 +7,7 @@ import {
   MAX_SECRET_MOUNT_NAMES,
 } from '@/lib/copilot/secret-mount-policy'
 import { decryptSecret } from '@/lib/core/security/encryption'
+import { setRecordValue } from '@/lib/core/utils/records'
 import { checkWorkspaceAccess } from '@/lib/workspaces/permissions/utils'
 import type { ResolvedSecretTraceCatalogEntry } from '@/executor/utils/resolved-secret-trace-registry'
 
@@ -70,7 +71,7 @@ function encryptedVariables(row: { variables: unknown } | undefined): Record<str
     return {}
   const result: Record<string, string> = {}
   for (const [name, value] of Object.entries(row.variables)) {
-    if (typeof value === 'string') result[name] = value
+    if (typeof value === 'string') setRecordValue(result, name, value)
   }
   return result
 }

apps/sim/lib/core/utils/records.test.ts

@@ -29,6 +29,14 @@ describe('record normalization utilities', () => {
     expect(normalizeStringRecord([])).toEqual({})
   })
 
+  it('preserves own __proto__ keys without changing the record prototype', () => {
+    const normalized = normalizeStringRecord(Object.fromEntries([['__proto__', 'secret-value']]))
+
+    expect(Object.hasOwn(normalized, '__proto__')).toBe(true)
+    expect(normalized.__proto__).toBe('secret-value')
+    expect(Object.getPrototypeOf(normalized)).toBe(Object.prototype)
+  })
+
   it('normalizes record maps by dropping malformed entries', () => {
     expect(
       normalizeRecordMap({

apps/sim/lib/core/utils/records.ts

@@ -3,6 +3,15 @@ import { isPlainRecord } from '@sim/utils/object'
 export type UnknownRecord = Record<string, unknown>
 export type StringRecord = Record<string, string>
 
+export function setRecordValue(record: Record<string, unknown>, key: string, value: unknown): void {
+  Object.defineProperty(record, key, {
+    value,
+    enumerable: true,
+    configurable: true,
+    writable: true,
+  })
+}
+
 /**
  * Normalizes optional execution context maps to the record shape expected by
  * internal API contracts.
@@ -25,7 +34,11 @@ export function normalizeStringRecord(value: unknown): StringRecord {
     if (entryValue === undefined || entryValue === null) {
       continue
     }
-    normalized[key] = typeof entryValue === 'string' ? entryValue : String(entryValue)
+    setRecordValue(
+      normalized,
+      key,
+      typeof entryValue === 'string' ? entryValue : String(entryValue)
+    )
   }
   return normalized
 }
@@ -41,7 +54,7 @@ export function normalizeRecordMap(value: unknown): Record<string, UnknownRecord
   const normalized: Record<string, UnknownRecord> = {}
   for (const [key, entryValue] of Object.entries(value)) {
     if (isPlainRecord(entryValue)) {
-      normalized[key] = entryValue
+      setRecordValue(normalized, key, entryValue)
     }
   }
   return normalized
@@ -72,7 +85,7 @@ export function normalizeWorkflowVariables(value: unknown): UnknownRecord {
     const key = id ?? name
 
     if (key) {
-      normalized[key] = variable
+      setRecordValue(normalized, key, variable)
     }
   }