Function handleExecutePost

apps/sim/app/api/workflows/[id]/execute/route.ts:375–1799

(
  req: NextRequest,
  params: Promise<{ id: string }>
)

)

async function handleExecutePost(
  req: NextRequest,
  params: Promise<{ id: string }>
): Promise<NextResponse | Response> {
  const requestId = generateRequestId()
  const { id: workflowId } = await params
  let reqLogger = logger.withMetadata({ requestId, workflowId })

  const incomingCallChain = parseCallChain(req.headers.get(SIM_VIA_HEADER))
  const callChainError = validateCallChain(incomingCallChain)
  if (callChainError) {
    reqLogger.warn(`Call chain rejected: ${callChainError}`)
    return NextResponse.json({ error: callChainError }, { status: 409 })
  }
  const callChain = buildNextCallChain(incomingCallChain, workflowId)

  // Hoisted so the outer catch can release a reserved billing slot when a throw
  // after preprocessExecution exits before the stream takes over its release.
  let executionId = ''

  try {
    const auth = await checkHybridAuth(req, { requireWorkflowId: false })

    // CSRF guard: reject session-cookie execution that is provably cross-site
    // (a different site driving the user's browser). same-origin and same-site
    // are allowed so multi-subdomain deployments (e.g. www.<domain> calling
    // <domain>) keep working. Scoped to session auth — API-key / public-API /
    // internal-JWT callers don't use cookies. Not a defense against a non-browser
    // client forging headers; that's covered by the credit/rate-limit gates.
    if (auth.success && auth.authType === AuthType.SESSION && isCrossSiteSessionRequest(req)) {
      reqLogger.warn('Rejected cross-site session-authenticated execute request')
      return NextResponse.json({ error: 'Access denied' }, { status: 403 })
    }

    const isMcpBridgeRequest =
      auth.authType === AuthType.INTERNAL_JWT && req.headers.get(MCP_TOOL_BRIDGE_HEADER) === 'true'
    const useMcpBridgeAuthenticatedUserAsActor =
      isMcpBridgeRequest && req.headers.get(MCP_TOOL_BRIDGE_ACTOR_HEADER) === 'authenticated-user'

    let userId: string
    let isPublicApiAccess = false
    let gateWorkspaceId: string | undefined

    if (!auth.success || !auth.userId) {
      const hasExplicitCredentials =
        req.headers.has('x-api-key') || req.headers.get('authorization')?.startsWith('Bearer ')
      if (hasExplicitCredentials) {
        return NextResponse.json({ error: auth.error || 'Unauthorized' }, { status: 401 })
      }

      const [wf] = await db
        .select({
          isPublicApi: workflowTable.isPublicApi,
          isDeployed: workflowTable.isDeployed,
          userId: workflowTable.userId,
          workspaceId: workflowTable.workspaceId,
        })
        .from(workflowTable)