fix(auth): bind legacy execution actors to principals

Author: TheodoreSpeaks

apps/sim/lib/auth/internal-delegation.test.ts

@@ -102,6 +102,41 @@ describe('bindInternalExecutorDelegation', () => {
     })
   })
 
+  it('binds the trusted legacy execution actor only for an actorless principal', async () => {
+    const principal = await bindInternalExecutorDelegation(
+      {
+        ...claims,
+        subjectUserId: undefined,
+        principal: {
+          kind: 'system',
+          serviceId: 'schedule',
+          workspaceId: 'workspace-1',
+          workflowId: 'workflow-1',
+        },
+      },
+      {
+        audience: 'sim:workspace-files',
+        compatibilityActorUserId: 'execution-actor',
+      }
+    )
+
+    expect(principal.subjectUserId).toBeUndefined()
+    expect(principal.delegationContext.compatibilityActor).toEqual({
+      kind: 'legacy_execution_user',
+      userId: 'execution-actor',
+    })
+  })
+
+  it('rejects a compatibility actor when the delegation has a user subject', async () => {
+    await expect(
+      bindInternalExecutorDelegation(claims, {
+        audience: 'sim:workspace-files',
+        compatibilityActorUserId: 'execution-actor',
+      })
+    ).rejects.toThrow('cannot bind a compatibility actor to a user subject')
+    expect(mockResolveWorkflow).not.toHaveBeenCalled()
+  })
+
   it('binds deployed child authority to its exact historical deployment version', async () => {
     const currentWorkflow = {
       workflowId: 'child-workflow',
@@ -260,6 +295,16 @@ describe('bindInternalExecutorDelegation', () => {
     expect(mockResolveWorkflow).not.toHaveBeenCalled()
   })
 
+  it('fails before canonical loading when the compatibility actor is empty', async () => {
+    await expect(
+      bindInternalExecutorDelegation(claims, {
+        audience: 'sim:workspace-files',
+        compatibilityActorUserId: ' ',
+      })
+    ).rejects.toThrow('Internal delegation execution actor must not be empty')
+    expect(mockResolveWorkflow).not.toHaveBeenCalled()
+  })
+
   it('classifies a missing canonical execution as an invalid delegation binding', async () => {
     mockResolveRun.mockRejectedValue(new OrchestrationError('not_found', 'Workflow run not found'))
 

apps/sim/lib/auth/internal-delegation.ts

@@ -15,6 +15,7 @@ import {
 export interface BindInternalExecutorDelegationOptions {
   audience: string
   resourceScope?: DelegatedPrincipal['resourceScope']
+  compatibilityActorUserId?: string
 }
 
 export class InvalidInternalDelegationBindingError extends Error {
@@ -30,6 +31,12 @@ export async function bindInternalExecutorDelegation(
   options: BindInternalExecutorDelegationOptions
 ): Promise<BoundWorkflowExecutionDelegatedPrincipal> {
   if (!options.audience.trim()) throw new Error('Internal delegation audience must not be empty')
+  if (options.compatibilityActorUserId !== undefined && !options.compatibilityActorUserId.trim()) {
+    throw new Error('Internal delegation execution actor must not be empty')
+  }
+  if (claims.subjectUserId && options.compatibilityActorUserId) {
+    throw new Error('Internal delegation cannot bind a compatibility actor to a user subject')
+  }
 
   let context: ActiveWorkflowApplicationContext
   let rootDeploymentVersionId: string | null | undefined
@@ -107,6 +114,14 @@ export async function bindInternalExecutorDelegation(
       ...(claims.executionId ? { executionId: claims.executionId } : {}),
       ...(claims.principal ? { principal: claims.principal } : {}),
       ...(claims.currentWorkflow ? { currentWorkflow: claims.currentWorkflow } : {}),
+      ...(options.compatibilityActorUserId
+        ? {
+            compatibilityActor: {
+              kind: 'legacy_execution_user',
+              userId: options.compatibilityActorUserId,
+            } as const,
+          }
+        : {}),
     },
   }
 }

apps/sim/lib/auth/principal.test.ts

@@ -7,6 +7,7 @@ import {
   requirePrincipalSubjectUserId,
   resolvePrincipalAttribution,
   resolvePrincipalAuditAttribution,
+  resolvePrincipalExecutionActorUserId,
   resolvePrincipalSubject,
   resolvePrincipalSubjectUserId,
   serializePrincipal,
@@ -108,6 +109,49 @@ describe('principal subject users', () => {
     ).toBeUndefined()
   })
 
+  it('resolves only a principal-bound compatibility actor for actorless execution', () => {
+    const principal = {
+      kind: 'delegated' as const,
+      serviceId: 'executor' as const,
+      workspaceId: 'workspace-1',
+      delegationId: 'delegation-1',
+      audience: 'sim:test',
+      issuedAt: new Date('2026-01-01T00:00:00Z'),
+      expiresAt: new Date('2026-01-01T00:05:00Z'),
+      delegationContext: {
+        kind: 'workflow_execution' as const,
+        workflowId: 'workflow-1',
+        currentWorkflow: {
+          workflowId: 'workflow-1',
+          mode: 'deployment' as const,
+          deploymentVersionId: 'deployment-1',
+        },
+        compatibilityActor: {
+          kind: 'legacy_execution_user' as const,
+          userId: 'execution-actor',
+        },
+      },
+    }
+
+    expect(resolvePrincipalSubjectUserId(principal)).toBeUndefined()
+    expect(resolvePrincipalExecutionActorUserId(principal)).toBe('execution-actor')
+    expect(
+      resolvePrincipalExecutionActorUserId({
+        ...principal,
+        subjectUserId: 'authenticated-user',
+      })
+    ).toBe('authenticated-user')
+    expect(
+      resolvePrincipalExecutionActorUserId({
+        ...principal,
+        delegationContext: {
+          ...principal.delegationContext,
+          currentWorkflow: { workflowId: 'workflow-1', mode: 'draft' },
+        },
+      })
+    ).toBeUndefined()
+  })
+
   it('fails fast instead of fabricating a workspace-key subject', () => {
     expect(() =>
       requirePrincipalSubjectUserId({

apps/sim/lib/copilot/tools/handlers/deployment/manage.ts

@@ -395,7 +395,6 @@ export async function executeLoadDeployment(
       workflowId,
       assertedWorkspaceId: context.workspaceId,
       version: target.version,
-      executionActorUserId: context.userId,
     })
 
     const label = target.version === 'active' ? 'the live deployment' : `version ${target.version}`

apps/sim/lib/copilot/tools/handlers/oauth.test.ts

@@ -53,7 +53,6 @@ describe('executeOAuthGetAuthLink', () => {
       workspaceId: 'workspace-1',
       providerName: 'gmail',
       credentialId: undefined,
-      executionActorUserId: 'user-1',
     })
     const url = new URL((result.output as { oauth_url: string }).oauth_url)
     expect(url.pathname).toBe('/api/auth/oauth2/authorize')

apps/sim/lib/copilot/tools/handlers/oauth.ts

@@ -39,7 +39,6 @@ export async function executeOAuthGetAuthLink(
       workspaceId,
       providerName,
       credentialId,
-      executionActorUserId: context.userId,
     })
     const callbackURL = context.workflowId
       ? `${baseUrl}/workspace/${workspaceId}/w/${context.workflowId}`

apps/sim/lib/core/orchestration/types.ts

@@ -109,12 +109,7 @@ export function asOrchestrationError(error: unknown): OrchestrationError | null
   return null
 }
 
-/**
- * Transport metadata available to an application operation. HTTP callers carry
- * headers for audit capture; executor adapters may also preserve the legacy
- * execution actor used by pre-application-boundary internal routes.
- */
+/** Transport metadata available to an application operation for audit capture. */
 export interface OrchestrationRequestContext {
   headers: { get(name: string): string | null }
-  executionActorUserId?: string
 }

apps/sim/lib/credentials/application/authorization.ts

@@ -1,4 +1,4 @@
-import { type Principal, resolvePrincipalSubjectUserId } from '@sim/auth/principal'
+import { type Principal, resolvePrincipalExecutionActorUserId } from '@sim/auth/principal'
 import type { WorkspaceDelegationPolicy } from '@/lib/core/application'
 import { OrchestrationError } from '@/lib/core/orchestration/types'
 import type { ManagedOAuthCredentialApplicationContext } from '@/lib/credentials/managed-oauth'
@@ -26,15 +26,12 @@ export const managedOAuthCredentialDelegationPolicy = {
 /**
  * Resolves the user whose credential grants an operation evaluates.
  *
- * `executionActorUserId` is the user the legacy internal route authenticated as.
- * Workspace authorization remains principal-based, and a principal subject
- * always takes precedence over this compatibility value.
+ * Actorless execution uses only the compatibility actor bound into the executor
+ * principal by the trusted runtime. Workspace authorization remains
+ * principal-based, and a principal subject always takes precedence.
  */
-export function requireCredentialExecutionUserId(
-  principal: Principal,
-  executionActorUserId?: string
-): string {
-  const userId = resolvePrincipalSubjectUserId(principal) ?? executionActorUserId
+export function requireCredentialExecutionUserId(principal: Principal): string {
+  const userId = resolvePrincipalExecutionActorUserId(principal)
   if (!userId) {
     throw new OrchestrationError(
       'forbidden',

apps/sim/lib/credentials/application/authorized-credential-use-case.ts

@@ -76,9 +76,7 @@ type AuthorizedCredentialUseCaseDefinition<
 > = Omit<
   AuthorizedWorkspaceUseCaseDefinition<O, I, C, R>,
   'authorizationOptions' | 'authorizeResource'
-> & {
-  resolveExecutionActorUserId?: (input: I) => string | undefined
-}
+>
 
 export function defineAuthorizedCredentialUseCase<
   const O extends CredentialOperation,
@@ -89,10 +87,10 @@ export function defineAuthorizedCredentialUseCase<
   return defineAuthorizedWorkspaceUseCase({
     ...definition,
     authorizationOptions: { delegation: credentialDelegationPolicy },
-    async authorizeResource({ principal, input, context }) {
+    async authorizeResource({ principal, context }) {
       const actor = await getCredentialActorContext(
         context.credential.id,
-        requireCredentialExecutionUserId(principal, definition.resolveExecutionActorUserId?.(input))
+        requireCredentialExecutionUserId(principal)
       )
       if (
         !actor.credential ||

apps/sim/lib/credentials/application/connection-target.test.ts

@@ -146,13 +146,25 @@ describe('resolveCredentialConnectionTarget', () => {
       audience: 'sim:credentials',
       issuedAt: new Date('2026-08-28T00:00:00.000Z'),
       expiresAt: new Date('2099-08-28T00:00:00.000Z'),
+      delegationContext: {
+        kind: 'workflow_execution' as const,
+        workflowId: 'workflow-1',
+        currentWorkflow: {
+          workflowId: 'workflow-1',
+          mode: 'deployment' as const,
+          deploymentVersionId: 'deployment-1',
+        },
+        compatibilityActor: {
+          kind: 'legacy_execution_user' as const,
+          userId: 'execution-actor',
+        },
+      },
     }
 
     await resolveCredentialConnectionTarget({
       principal: actorlessPrincipal,
       context,
       credentialId: 'credential-1',
-      executionActorUserId: 'execution-actor',
     })
 
     expect(mocks.getCredentialActorContext).toHaveBeenCalledWith('credential-1', 'execution-actor')