feat(credentials): bind executor managed-OAuth delegations in-process

Author: waleedlatif1

apps/sim/lib/credentials/application/managed-oauth-delegation.test.ts

@@ -0,0 +1,99 @@
+/**
+ * @vitest-environment node
+ */
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { ExecutorDelegationOrigin } from '@/executor/types'
+
+const { mockBindInternalExecutorDelegation } = vi.hoisted(() => ({
+  mockBindInternalExecutorDelegation: vi.fn(),
+}))
+
+vi.mock('@/lib/auth/internal-delegation', () => ({
+  bindInternalExecutorDelegation: mockBindInternalExecutorDelegation,
+  InvalidInternalDelegationBindingError: class InvalidInternalDelegationBindingError extends Error {},
+}))
+
+vi.mock('@/lib/auth/internal', () => ({
+  InvalidInternalDelegationTokenError: class InvalidInternalDelegationTokenError extends Error {},
+  verifyInternalDelegationToken: vi.fn(),
+}))
+
+import { InvalidInternalDelegationBindingError } from '@/lib/auth/internal-delegation'
+import {
+  bindExecutorManagedOAuthDelegation,
+  InvalidManagedOAuthDelegationError,
+} from '@/lib/credentials/application/managed-oauth-delegation'
+
+function delegationOrigin(
+  overrides: Partial<ExecutorDelegationOrigin> = {}
+): ExecutorDelegationOrigin {
+  return {
+    subjectUserId: 'user-origin',
+    workflowId: 'workflow-origin',
+    executionId: 'execution-origin',
+    currentWorkflow: { workflowId: 'workflow-origin' },
+    ...overrides,
+  } as ExecutorDelegationOrigin
+}
+
+describe('bindExecutorManagedOAuthDelegation', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockBindInternalExecutorDelegation.mockImplementation(async (claims, options) => ({
+      kind: 'delegated',
+      serviceId: 'executor',
+      subjectUserId: claims.subjectUserId,
+      workspaceId: 'workspace-canonical',
+      delegationId: claims.delegationId,
+      audience: options.audience,
+      resourceScope: options.resourceScope,
+    }))
+  })
+
+  it('requires current workflow authority before binding', async () => {
+    await expect(
+      bindExecutorManagedOAuthDelegation(delegationOrigin({ currentWorkflow: undefined }), 'cred-1')
+    ).rejects.toThrow('Managed credential delegation is missing current workflow authority')
+    expect(mockBindInternalExecutorDelegation).not.toHaveBeenCalled()
+  })
+
+  it('binds the origin to the managed-OAuth audience scoped to one credential', async () => {
+    const principal = await bindExecutorManagedOAuthDelegation(delegationOrigin(), 'cred-1')
+
+    expect(mockBindInternalExecutorDelegation).toHaveBeenCalledWith(
+      expect.objectContaining({
+        serviceId: 'executor',
+        subjectUserId: 'user-origin',
+        workflowId: 'workflow-origin',
+        executionId: 'execution-origin',
+        currentWorkflow: { workflowId: 'workflow-origin' },
+      }),
+      expect.objectContaining({
+        audience: 'sim:managed-oauth-credentials',
+        resourceScope: { credentialId: 'cred-1' },
+      })
+    )
+    expect(principal).toMatchObject({
+      audience: 'sim:managed-oauth-credentials',
+      resourceScope: { credentialId: 'cred-1' },
+    })
+  })
+
+  it('wraps binding rejections into the managed-OAuth delegation error', async () => {
+    mockBindInternalExecutorDelegation.mockRejectedValue(
+      new InvalidInternalDelegationBindingError('stale workflow context')
+    )
+
+    await expect(
+      bindExecutorManagedOAuthDelegation(delegationOrigin(), 'cred-1')
+    ).rejects.toBeInstanceOf(InvalidManagedOAuthDelegationError)
+  })
+
+  it('rethrows unexpected binding failures unchanged', async () => {
+    mockBindInternalExecutorDelegation.mockRejectedValue(new Error('db unavailable'))
+
+    await expect(bindExecutorManagedOAuthDelegation(delegationOrigin(), 'cred-1')).rejects.toThrow(
+      'db unavailable'
+    )
+  })
+})

apps/sim/lib/credentials/application/managed-oauth-delegation.ts

@@ -8,6 +8,8 @@ import {
   InvalidInternalDelegationBindingError,
 } from '@/lib/auth/internal-delegation'
 import { MANAGED_OAUTH_DELEGATION_AUDIENCE } from '@/lib/credentials/application/authorization'
+import { createExecutorPrincipalFromDelegationOrigin } from '@/lib/internal/principals/executor'
+import type { ExecutorDelegationOrigin } from '@/executor/types'
 
 export class InvalidManagedOAuthDelegationError extends Error {
   constructor() {
@@ -39,3 +41,32 @@ export async function authenticateManagedOAuthDelegation(
     throw error
   }
 }
+
+/**
+ * In-process sibling of {@link authenticateManagedOAuthDelegation}: binds the
+ * executor's own delegation origin to one managed credential without minting and
+ * re-verifying a delegation JWT. The binding still re-validates the workflow and
+ * deployment context, so trust matches the wire path minus the signature check,
+ * which proves nothing when the executor is the caller.
+ */
+export async function bindExecutorManagedOAuthDelegation(
+  origin: ExecutorDelegationOrigin,
+  credentialId: string
+): Promise<WorkflowExecutionDelegatedPrincipal> {
+  if (!origin.currentWorkflow) {
+    throw new Error('Managed credential delegation is missing current workflow authority')
+  }
+
+  try {
+    return await createExecutorPrincipalFromDelegationOrigin(
+      origin,
+      MANAGED_OAUTH_DELEGATION_AUDIENCE,
+      { credentialId }
+    )
+  } catch (error) {
+    if (error instanceof InvalidInternalDelegationBindingError) {
+      throw new InvalidManagedOAuthDelegationError()
+    }
+    throw error
+  }
+}

apps/sim/lib/internal/principals/executor.ts

@@ -29,7 +29,13 @@ export function resolveExecutorOriginSubject(origin: ExecutorDelegationOrigin):
   return subjectUserId
 }
 
-async function bindExecutorPrincipal(
+/**
+ * Binds an executor delegation origin to a delegated principal in-process,
+ * without minting and re-verifying a delegation JWT. The underlying binding
+ * still re-validates the workflow and deployment context, so trust matches the
+ * wire path minus the signature check, which proves nothing in-process.
+ */
+export async function createExecutorPrincipalFromDelegationOrigin(
   origin: ExecutorDelegationOrigin,
   audience: string,
   resourceScope?: DelegatedPrincipal['resourceScope'],
@@ -74,5 +80,11 @@ export async function createExecutorPrincipalFromExecutionContext({
 }: CreateExecutorPrincipalFromExecutionContextInput) {
   const origin = context.executorDelegationOrigin
   if (!origin) throw new ExecutorDelegationOriginRequiredError()
-  return bindExecutorPrincipal(origin, audience, resourceScope, expiresAt, context.userId)
+  return createExecutorPrincipalFromDelegationOrigin(
+    origin,
+    audience,
+    resourceScope,
+    expiresAt,
+    context.userId
+  )
 }