Merge pull request '캐릭터 챗봇' (#338) from test into main

Reviewed-on: #338

.gitignore

@@ -323,4 +323,7 @@ gradle-app.setting
 ### Gradle Patch ###
 **/build/
 
+.kiro/
+.junie
+
 # End of https://www.toptal.com/developers/gitignore/api/visualstudiocode,intellij,java,kotlin,macos,windows,eclipse,gradle

src/main/kotlin/kr/co/vividnext/sodalive/admin/chat/AdminChatBannerController.kt

@@ -0,0 +1,229 @@
+package kr.co.vividnext.sodalive.admin.chat
+
+import com.amazonaws.services.s3.model.ObjectMetadata
+import com.fasterxml.jackson.databind.ObjectMapper
+import kr.co.vividnext.sodalive.admin.chat.character.dto.ChatCharacterSearchListPageResponse
+import kr.co.vividnext.sodalive.admin.chat.character.service.AdminChatCharacterService
+import kr.co.vividnext.sodalive.admin.chat.dto.ChatCharacterBannerListPageResponse
+import kr.co.vividnext.sodalive.admin.chat.dto.ChatCharacterBannerRegisterRequest
+import kr.co.vividnext.sodalive.admin.chat.dto.ChatCharacterBannerResponse
+import kr.co.vividnext.sodalive.admin.chat.dto.ChatCharacterBannerUpdateRequest
+import kr.co.vividnext.sodalive.admin.chat.dto.UpdateBannerOrdersRequest
+import kr.co.vividnext.sodalive.aws.s3.S3Uploader
+import kr.co.vividnext.sodalive.chat.character.service.ChatCharacterBannerService
+import kr.co.vividnext.sodalive.common.ApiResponse
+import kr.co.vividnext.sodalive.common.SodaException
+import kr.co.vividnext.sodalive.utils.generateFileName
+import org.springframework.beans.factory.annotation.Value
+import org.springframework.security.access.prepost.PreAuthorize
+import org.springframework.web.bind.annotation.DeleteMapping
+import org.springframework.web.bind.annotation.GetMapping
+import org.springframework.web.bind.annotation.PathVariable
+import org.springframework.web.bind.annotation.PostMapping
+import org.springframework.web.bind.annotation.PutMapping
+import org.springframework.web.bind.annotation.RequestBody
+import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RequestParam
+import org.springframework.web.bind.annotation.RequestPart
+import org.springframework.web.bind.annotation.RestController
+import org.springframework.web.multipart.MultipartFile
+
+@RestController
+@RequestMapping("/admin/chat/banner")
+@PreAuthorize("hasRole('ADMIN')")
+class AdminChatBannerController(
+    private val bannerService: ChatCharacterBannerService,
+    private val adminCharacterService: AdminChatCharacterService,
+    private val s3Uploader: S3Uploader,
+
+    @Value("\${cloud.aws.s3.bucket}")
+    private val s3Bucket: String,
+
+    @Value("\${cloud.aws.cloud-front.host}")
+    private val imageHost: String
+) {
+    /**
+     * 활성화된 배너 목록 조회 API
+     *
+     * @param page 페이지 번호 (0부터 시작, 기본값 0)
+     * @param size 페이지 크기 (기본값 20)
+     * @return 페이징된 배너 목록
+     */
+    @GetMapping("/list")
+    fun getBannerList(
+        @RequestParam(defaultValue = "0") page: Int,
+        @RequestParam(defaultValue = "20") size: Int
+    ) = run {
+        val pageable = adminCharacterService.createDefaultPageRequest(page, size)
+        val banners = bannerService.getActiveBanners(pageable)
+        val response = ChatCharacterBannerListPageResponse(
+            totalCount = banners.totalElements,
+            content = banners.content.map { ChatCharacterBannerResponse.from(it, imageHost) }
+        )
+
+        ApiResponse.ok(response)
+    }
+
+    /**
+     * 배너 상세 조회 API
+     *
+     * @param bannerId 배너 ID
+     * @return 배너 상세 정보
+     */
+    @GetMapping("/{bannerId}")
+    fun getBannerDetail(@PathVariable bannerId: Long) = run {
+        val banner = bannerService.getBannerById(bannerId)
+        val response = ChatCharacterBannerResponse.from(banner, imageHost)
+
+        ApiResponse.ok(response)
+    }
+
+    /**
+     * 캐릭터 검색 API (배너 등록을 위한)
+     *
+     * @param searchTerm 검색어 (이름, 설명, MBTI, 태그)
+     * @param page 페이지 번호 (0부터 시작, 기본값 0)
+     * @param size 페이지 크기 (기본값 20)
+     * @return 검색된 캐릭터 목록
+     */
+    @GetMapping("/search-character")
+    fun searchCharacters(
+        @RequestParam searchTerm: String,
+        @RequestParam(defaultValue = "0") page: Int,
+        @RequestParam(defaultValue = "20") size: Int
+    ) = run {
+        val pageable = adminCharacterService.createDefaultPageRequest(page, size)
+        val pageResult = adminCharacterService.searchCharacters(searchTerm, pageable, imageHost)
+        val response = ChatCharacterSearchListPageResponse(
+            totalCount = pageResult.totalElements,
+            content = pageResult.content
+        )
+
+        ApiResponse.ok(response)
+    }
+
+    /**
+     * 배너 등록 API
+     *
+     * @param image 배너 이미지
+     * @param requestString 배너 등록 요청 정보 (캐릭터 ID와 선택적으로 정렬 순서 포함)
+     * @return 등록된 배너 정보
+     */
+    @PostMapping("/register")
+    fun registerBanner(
+        @RequestPart("image") image: MultipartFile,
+        @RequestPart("request") requestString: String
+    ) = run {
+        val objectMapper = ObjectMapper()
+        val request = objectMapper.readValue(
+            requestString,
+            ChatCharacterBannerRegisterRequest::class.java
+        )
+
+        // 1. 먼저 빈 이미지 경로로 배너 등록 (정렬 순서 포함)
+        val banner = bannerService.registerBanner(
+            characterId = request.characterId,
+            imagePath = ""
+        )
+
+        // 2. 배너 ID를 사용하여 이미지 업로드
+        val imagePath = saveImage(banner.id!!, image)
+
+        // 3. 이미지 경로로 배너 업데이트
+        val updatedBanner = bannerService.updateBanner(banner.id!!, imagePath)
+
+        val response = ChatCharacterBannerResponse.from(updatedBanner, imageHost)
+
+        ApiResponse.ok(response)
+    }
+
+    /**
+     * 이미지를 S3에 업로드하고 경로를 반환
+     *
+     * @param bannerId 배너 ID (이미지 경로에 사용)
+     * @param image 업로드할 이미지 파일
+     * @return 업로드된 이미지 경로
+     */
+    private fun saveImage(bannerId: Long, image: MultipartFile): String {
+        try {
+            val metadata = ObjectMetadata()
+            metadata.contentLength = image.size
+
+            val fileName = generateFileName("character-banner")
+
+            // S3에 이미지 업로드 (배너 ID를 경로에 사용)
+            return s3Uploader.upload(
+                inputStream = image.inputStream,
+                bucket = s3Bucket,
+                filePath = "characters/banners/$bannerId/$fileName",
+                metadata = metadata
+            )
+        } catch (e: Exception) {
+            throw SodaException("이미지 저장에 실패했습니다: ${e.message}")
+        }
+    }
+
+    /**
+     * 배너 수정 API
+     *
+     * @param image 배너 이미지
+     * @param requestString 배너 수정 요청 정보 (배너 ID와 선택적으로 캐릭터 ID 포함)
+     * @return 수정된 배너 정보
+     */
+    @PutMapping("/update")
+    fun updateBanner(
+        @RequestPart("image") image: MultipartFile,
+        @RequestPart("request") requestString: String
+    ) = run {
+        val objectMapper = ObjectMapper()
+        val request = objectMapper.readValue(
+            requestString,
+            ChatCharacterBannerUpdateRequest::class.java
+        )
+        // 배너 정보 조회
+        bannerService.getBannerById(request.bannerId)
+
+        // 배너 ID를 사용하여 이미지 업로드
+        val imagePath = saveImage(request.bannerId, image)
+
+        // 배너 수정 (이미지와 캐릭터 모두 수정 가능)
+        val updatedBanner = bannerService.updateBanner(
+            bannerId = request.bannerId,
+            imagePath = imagePath,
+            characterId = request.characterId
+        )
+
+        val response = ChatCharacterBannerResponse.from(updatedBanner, imageHost)
+
+        ApiResponse.ok(response)
+    }
+
+    /**
+     * 배너 삭제 API (소프트 삭제)
+     *
+     * @param bannerId 배너 ID
+     * @return 성공 여부
+     */
+    @DeleteMapping("/{bannerId}")
+    fun deleteBanner(@PathVariable bannerId: Long) = run {
+        bannerService.deleteBanner(bannerId)
+
+        ApiResponse.ok("배너가 성공적으로 삭제되었습니다.")
+    }
+
+    /**
+     * 배너 정렬 순서 일괄 변경 API
+     * ID 목록의 순서대로 정렬 순서를 1부터 순차적으로 설정합니다.
+     *
+     * @param request 정렬 순서 일괄 변경 요청 정보 (배너 ID 목록)
+     * @return 성공 메시지
+     */
+    @PutMapping("/orders")
+    fun updateBannerOrders(
+        @RequestBody request: UpdateBannerOrdersRequest
+    ) = run {
+        bannerService.updateBannerOrders(request.ids)
+
+        ApiResponse.ok(null, "배너 정렬 순서가 성공적으로 변경되었습니다.")
+    }
+}

src/main/kotlin/kr/co/vividnext/sodalive/admin/chat/character/AdminChatCharacterController.kt

@@ -0,0 +1,388 @@
+package kr.co.vividnext.sodalive.admin.chat.character
+
+import com.amazonaws.services.s3.model.ObjectMetadata
+import com.fasterxml.jackson.databind.ObjectMapper
+import kr.co.vividnext.sodalive.admin.chat.character.dto.ChatCharacterRegisterRequest
+import kr.co.vividnext.sodalive.admin.chat.character.dto.ChatCharacterUpdateRequest
+import kr.co.vividnext.sodalive.admin.chat.character.dto.ExternalApiResponse
+import kr.co.vividnext.sodalive.admin.chat.character.service.AdminChatCharacterService
+import kr.co.vividnext.sodalive.aws.s3.S3Uploader
+import kr.co.vividnext.sodalive.chat.character.CharacterType
+import kr.co.vividnext.sodalive.chat.character.service.ChatCharacterService
+import kr.co.vividnext.sodalive.common.ApiResponse
+import kr.co.vividnext.sodalive.common.SodaException
+import kr.co.vividnext.sodalive.utils.generateFileName
+import org.springframework.beans.factory.annotation.Value
+import org.springframework.http.HttpEntity
+import org.springframework.http.HttpHeaders
+import org.springframework.http.HttpMethod
+import org.springframework.http.MediaType
+import org.springframework.http.client.SimpleClientHttpRequestFactory
+import org.springframework.security.access.prepost.PreAuthorize
+import org.springframework.web.bind.annotation.GetMapping
+import org.springframework.web.bind.annotation.PathVariable
+import org.springframework.web.bind.annotation.PostMapping
+import org.springframework.web.bind.annotation.PutMapping
+import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RequestParam
+import org.springframework.web.bind.annotation.RequestPart
+import org.springframework.web.bind.annotation.RestController
+import org.springframework.web.client.RestTemplate
+import org.springframework.web.multipart.MultipartFile
+
+@RestController
+@RequestMapping("/admin/chat/character")
+@PreAuthorize("hasRole('ADMIN')")
+class AdminChatCharacterController(
+    private val service: ChatCharacterService,
+    private val adminService: AdminChatCharacterService,
+    private val s3Uploader: S3Uploader,
+
+    @Value("\${weraser.api-key}")
+    private val apiKey: String,
+
+    @Value("\${weraser.api-url}")
+    private val apiUrl: String,
+
+    @Value("\${cloud.aws.s3.bucket}")
+    private val s3Bucket: String,
+
+    @Value("\${cloud.aws.cloud-front.host}")
+    private val imageHost: String
+) {
+    /**
+     * 활성화된 캐릭터 목록 조회 API
+     *
+     * @param page 페이지 번호 (0부터 시작, 기본값 0)
+     * @param size 페이지 크기 (기본값 20)
+     * @return 페이징된 캐릭터 목록
+     */
+    @GetMapping("/list")
+    fun getCharacterList(
+        @RequestParam(defaultValue = "0") page: Int,
+        @RequestParam(defaultValue = "20") size: Int
+    ) = run {
+        val pageable = adminService.createDefaultPageRequest(page, size)
+        val response = adminService.getActiveChatCharacters(pageable, imageHost)
+
+        ApiResponse.ok(response)
+    }
+
+    /**
+     * 캐릭터 상세 정보 조회 API
+     *
+     * @param characterId 캐릭터 ID
+     * @return 캐릭터 상세 정보
+     */
+    @GetMapping("/{characterId}")
+    fun getCharacterDetail(
+        @PathVariable characterId: Long
+    ) = run {
+        val response = adminService.getChatCharacterDetail(characterId, imageHost)
+
+        ApiResponse.ok(response)
+    }
+
+    @PostMapping("/register")
+    fun registerCharacter(
+        @RequestPart("image") image: MultipartFile,
+        @RequestPart("request") requestString: String
+    ) = run {
+        // JSON 문자열을 ChatCharacterRegisterRequest 객체로 변환
+        val objectMapper = ObjectMapper()
+        val request = objectMapper.readValue(requestString, ChatCharacterRegisterRequest::class.java)
+
+        // 외부 API 호출 전 DB에 동일한 이름이 있는지 조회
+        val existingCharacter = service.findByName(request.name)
+        if (existingCharacter != null) {
+            throw SodaException("동일한 이름은 등록이 불가능합니다: ${request.name}")
+        }
+
+        // 1. 외부 API 호출
+        val characterUUID = callExternalApi(request)
+
+        // 2. ChatCharacter 저장
+        val chatCharacter = service.createChatCharacterWithDetails(
+            characterUUID = characterUUID,
+            name = request.name,
+            description = request.description,
+            systemPrompt = request.systemPrompt,
+            age = request.age?.toIntOrNull(),
+            gender = request.gender,
+            mbti = request.mbti,
+            speechPattern = request.speechPattern,
+            speechStyle = request.speechStyle,
+            appearance = request.appearance,
+            originalTitle = request.originalTitle,
+            originalLink = request.originalLink,
+            characterType = request.characterType?.let {
+                runCatching { CharacterType.valueOf(it) }
+                    .getOrDefault(CharacterType.Character)
+            } ?: CharacterType.Character,
+            tags = request.tags,
+            values = request.values,
+            hobbies = request.hobbies,
+            goals = request.goals,
+            memories = request.memories.map { Triple(it.title, it.content, it.emotion) },
+            personalities = request.personalities.map { Pair(it.trait, it.description) },
+            backgrounds = request.backgrounds.map { Pair(it.topic, it.description) },
+            relationships = request.relationships
+        )
+
+        // 3. 이미지 저장 및 ChatCharacter에 이미지 path 설정
+        val imagePath = saveImage(
+            characterId = chatCharacter.id!!,
+            image = image
+        )
+        chatCharacter.imagePath = imagePath
+        service.saveChatCharacter(chatCharacter)
+
+        ApiResponse.ok(null)
+    }
+
+    private fun callExternalApi(request: ChatCharacterRegisterRequest): String {
+        try {
+            val factory = SimpleClientHttpRequestFactory()
+            factory.setConnectTimeout(20000) // 20초
+            factory.setReadTimeout(20000) // 20초
+
+            val restTemplate = RestTemplate(factory)
+
+            val headers = HttpHeaders()
+            headers.set("x-api-key", apiKey) // 실제 API 키로 대체 필요
+            headers.contentType = MediaType.APPLICATION_JSON
+
+            // 외부 API에 전달하지 않을 필드(originalTitle, originalLink, characterType)를 제외하고 바디 구성
+            val body = mutableMapOf<String, Any>()
+            body["name"] = request.name
+            body["systemPrompt"] = request.systemPrompt
+            body["description"] = request.description
+            request.age?.let { body["age"] = it }
+            request.gender?.let { body["gender"] = it }
+            request.mbti?.let { body["mbti"] = it }
+            request.speechPattern?.let { body["speechPattern"] = it }
+            request.speechStyle?.let { body["speechStyle"] = it }
+            request.appearance?.let { body["appearance"] = it }
+            if (request.tags.isNotEmpty()) body["tags"] = request.tags
+            if (request.hobbies.isNotEmpty()) body["hobbies"] = request.hobbies
+            if (request.values.isNotEmpty()) body["values"] = request.values
+            if (request.goals.isNotEmpty()) body["goals"] = request.goals
+            if (request.relationships.isNotEmpty()) body["relationships"] = request.relationships
+            if (request.personalities.isNotEmpty()) body["personalities"] = request.personalities
+            if (request.backgrounds.isNotEmpty()) body["backgrounds"] = request.backgrounds
+            if (request.memories.isNotEmpty()) body["memories"] = request.memories
+
+            val httpEntity = HttpEntity(body, headers)
+
+            val response = restTemplate.exchange(
+                "$apiUrl/api/characters",
+                HttpMethod.POST,
+                httpEntity,
+                String::class.java
+            )
+
+            // 응답 파싱
+            val objectMapper = ObjectMapper()
+            val apiResponse = objectMapper.readValue(response.body, ExternalApiResponse::class.java)
+
+            // success가 false이면 throw
+            if (!apiResponse.success) {
+                throw SodaException(apiResponse.message ?: "등록에 실패했습니다. 다시 시도해 주세요.")
+            }
+
+            // success가 true이면 data.id 반환
+            return apiResponse.data?.id ?: throw SodaException("등록에 실패했습니다. 응답에 ID가 없습니다.")
+        } catch (e: Exception) {
+            e.printStackTrace()
+            throw SodaException("${e.message}, 등록에 실패했습니다. 다시 시도해 주세요.")
+        }
+    }
+
+    private fun saveImage(characterId: Long, image: MultipartFile): String {
+        try {
+            val metadata = ObjectMetadata()
+            metadata.contentLength = image.size
+
+            // S3에 이미지 업로드
+            return s3Uploader.upload(
+                inputStream = image.inputStream,
+                bucket = s3Bucket,
+                filePath = "characters/$characterId/${generateFileName(prefix = "character")}",
+                metadata = metadata
+            )
+        } catch (e: Exception) {
+            throw SodaException("이미지 저장에 실패했습니다: ${e.message}")
+        }
+    }
+
+    /**
+     * 캐릭터 수정 API
+     * 1. JSON 문자열을 ChatCharacterUpdateRequest 객체로 변환
+     * 2. ChatCharacterUpdateRequest를 확인해서 변경한 데이터가 있는지 확인
+     * 3. 이미지 있는지 확인
+     * 4. 2, 3번 중 하나라도 해당 하면 계속 진행
+     * 5. 2, 3번에 데이터 없으면 throw SodaException('변경된 데이터가 없습니다.')
+     *
+     * @param image 캐릭터 이미지 (선택적)
+     * @param requestString ChatCharacterUpdateRequest 객체를 JSON 문자열로 변환한 값
+     * @return ApiResponse 객체
+     * @throws SodaException 변경된 데이터가 없거나 캐릭터를 찾을 수 없는 경우
+     */
+    @PutMapping("/update")
+    fun updateCharacter(
+        @RequestPart(value = "image", required = false) image: MultipartFile?,
+        @RequestPart("request") requestString: String
+    ) = run {
+        // 1. JSON 문자열을 ChatCharacterUpdateRequest 객체로 변환
+        val objectMapper = ObjectMapper()
+        val request = objectMapper.readValue(requestString, ChatCharacterUpdateRequest::class.java)
+
+        // 2. ChatCharacterUpdateRequest를 확인해서 변경한 데이터가 있는지 확인
+        val hasChangedData = hasChanges(request) // 외부 API 대상으로의 변경 여부(3가지 필드 제외)
+
+        // 3. 이미지 있는지 확인
+        val hasImage = image != null && !image.isEmpty
+
+        // 3가지만 변경된 경우(외부 API 변경은 없지만 DB 변경은 있는 경우)를 허용하기 위해 별도 플래그 계산
+        val hasDbOnlyChanges =
+            request.originalTitle != null ||
+                request.originalLink != null ||
+                request.characterType != null
+
+        if (!hasChangedData && !hasImage && !hasDbOnlyChanges) {
+            throw SodaException("변경된 데이터가 없습니다.")
+        }
+
+        // 외부 API로 전달할 변경이 있을 때만 외부 API 호출(3가지 필드만 변경된 경우는 호출하지 않음)
+        if (hasChangedData) {
+            val chatCharacter = service.findById(request.id)
+                ?: throw SodaException("해당 ID의 캐릭터를 찾을 수 없습니다: ${request.id}")
+
+            // 이름이 수정된 경우 DB에 동일한 이름이 있는지 확인
+            if (request.name != null && request.name != chatCharacter.name) {
+                val existingCharacter = service.findByName(request.name)
+                if (existingCharacter != null) {
+                    throw SodaException("동일한 이름은 등록이 불가능합니다: ${request.name}")
+                }
+            }
+
+            callExternalApiForUpdate(chatCharacter.characterUUID, request)
+        }
+
+        // 이미지 경로 변수 초기화
+        // 이미지가 있으면 이미지 저장
+        val imagePath = if (hasImage) {
+            saveImage(
+                characterId = request.id,
+                image = image!!
+            )
+        } else {
+            null
+        }
+
+        // 엔티티 수정
+        service.updateChatCharacterWithDetails(
+            imagePath = imagePath,
+            request = request
+        )
+
+        ApiResponse.ok(null)
+    }
+
+    /**
+     * 요청에 변경된 데이터가 있는지 확인
+     * id를 제외한 모든 필드가 null이면 변경된 데이터가 없는 것으로 판단
+     *
+     * @param request 수정 요청 데이터
+     * @return 변경된 데이터가 있으면 true, 없으면 false
+     */
+    private fun hasChanges(request: ChatCharacterUpdateRequest): Boolean {
+        return request.systemPrompt != null ||
+            request.description != null ||
+            request.age != null ||
+            request.gender != null ||
+            request.mbti != null ||
+            request.speechPattern != null ||
+            request.speechStyle != null ||
+            request.appearance != null ||
+            request.isActive != null ||
+            request.tags != null ||
+            request.hobbies != null ||
+            request.values != null ||
+            request.goals != null ||
+            request.relationships != null ||
+            request.personalities != null ||
+            request.backgrounds != null ||
+            request.memories != null ||
+            request.name != null
+    }
+
+    /**
+     * 외부 API 호출 - 수정 API
+     * 변경된 데이터만 요청에 포함
+     *
+     * @param characterUUID 캐릭터 UUID
+     * @param request 수정 요청 데이터
+     */
+    private fun callExternalApiForUpdate(characterUUID: String, request: ChatCharacterUpdateRequest) {
+        try {
+            val factory = SimpleClientHttpRequestFactory()
+            factory.setConnectTimeout(20000) // 20초
+            factory.setReadTimeout(20000) // 20초
+
+            val restTemplate = RestTemplate(factory)
+
+            val headers = HttpHeaders()
+            headers.set("x-api-key", apiKey)
+            headers.contentType = MediaType.APPLICATION_JSON
+
+            // 변경된 데이터만 포함하는 맵 생성
+            val updateData = mutableMapOf<String, Any>()
+
+            // isActive = false인 경우 처리
+            if (request.isActive != null && !request.isActive) {
+                val inactiveName = "inactive_${request.name}"
+                val randomSuffix = "_" + java.util.UUID.randomUUID().toString().replace("-", "")
+                updateData["name"] = inactiveName + randomSuffix
+            } else {
+                request.name?.let { updateData["name"] = it }
+                request.systemPrompt?.let { updateData["systemPrompt"] = it }
+                request.description?.let { updateData["description"] = it }
+                request.age?.let { updateData["age"] = it }
+                request.gender?.let { updateData["gender"] = it }
+                request.mbti?.let { updateData["mbti"] = it }
+                request.speechPattern?.let { updateData["speechPattern"] = it }
+                request.speechStyle?.let { updateData["speechStyle"] = it }
+                request.appearance?.let { updateData["appearance"] = it }
+                request.tags?.let { updateData["tags"] = it }
+                request.hobbies?.let { updateData["hobbies"] = it }
+                request.values?.let { updateData["values"] = it }
+                request.goals?.let { updateData["goals"] = it }
+                request.relationships?.let { updateData["relationships"] = it }
+                request.personalities?.let { updateData["personalities"] = it }
+                request.backgrounds?.let { updateData["backgrounds"] = it }
+                request.memories?.let { updateData["memories"] = it }
+            }
+
+            val httpEntity = HttpEntity(updateData, headers)
+            val response = restTemplate.exchange(
+                "$apiUrl/api/characters/$characterUUID",
+                HttpMethod.PUT,
+                httpEntity,
+                String::class.java
+            )
+
+            // 응답 파싱
+            val objectMapper = ObjectMapper()
+            val apiResponse = objectMapper.readValue(response.body, ExternalApiResponse::class.java)
+
+            // success가 false이면 throw
+            if (!apiResponse.success) {
+                throw SodaException(apiResponse.message ?: "수정에 실패했습니다. 다시 시도해 주세요.")
+            }
+        } catch (e: Exception) {
+            e.printStackTrace()
+            throw SodaException("${e.message} 수정에 실패했습니다. 다시 시도해 주세요.")
+        }
+    }
+}

src/main/kotlin/kr/co/vividnext/sodalive/admin/chat/character/curation/CharacterCurationAdminController.kt

@@ -0,0 +1,82 @@
+package kr.co.vividnext.sodalive.admin.chat.character.curation
+
+import kr.co.vividnext.sodalive.common.ApiResponse
+import kr.co.vividnext.sodalive.common.SodaException
+import org.springframework.beans.factory.annotation.Value
+import org.springframework.security.access.prepost.PreAuthorize
+import org.springframework.web.bind.annotation.DeleteMapping
+import org.springframework.web.bind.annotation.GetMapping
+import org.springframework.web.bind.annotation.PathVariable
+import org.springframework.web.bind.annotation.PostMapping
+import org.springframework.web.bind.annotation.PutMapping
+import org.springframework.web.bind.annotation.RequestBody
+import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RestController
+
+@RestController
+@RequestMapping("/admin/chat/character/curation")
+@PreAuthorize("hasRole('ADMIN')")
+class CharacterCurationAdminController(
+    private val service: CharacterCurationAdminService,
+    @Value("\${cloud.aws.cloud-front.host}")
+    private val imageHost: String
+) {
+    @GetMapping("/list")
+    fun listAll(): ApiResponse<List<CharacterCurationListItemResponse>> =
+        ApiResponse.ok(service.listAll())
+
+    @GetMapping("/{curationId}/characters")
+    fun listCharacters(
+        @PathVariable curationId: Long
+    ): ApiResponse<List<CharacterCurationCharacterItemResponse>> {
+        val characters = service.listCharacters(curationId)
+        val items = characters.map {
+            CharacterCurationCharacterItemResponse(
+                id = it.id!!,
+                name = it.name,
+                description = it.description,
+                imageUrl = "$imageHost/${it.imagePath ?: "profile/default-profile.png"}"
+            )
+        }
+        return ApiResponse.ok(items)
+    }
+
+    @PostMapping("/register")
+    fun register(@RequestBody request: CharacterCurationRegisterRequest) =
+        ApiResponse.ok(service.register(request).id)
+
+    @PutMapping("/update")
+    fun update(@RequestBody request: CharacterCurationUpdateRequest) =
+        ApiResponse.ok(service.update(request).id)
+
+    @DeleteMapping("/{curationId}")
+    fun delete(@PathVariable curationId: Long) =
+        ApiResponse.ok(service.softDelete(curationId))
+
+    @PutMapping("/reorder")
+    fun reorder(@RequestBody request: CharacterCurationOrderUpdateRequest) =
+        ApiResponse.ok(service.reorder(request.ids))
+
+    @PostMapping("/{curationId}/characters")
+    fun addCharacter(
+        @PathVariable curationId: Long,
+        @RequestBody request: CharacterCurationAddCharacterRequest
+    ): ApiResponse<Boolean> {
+        val ids = request.characterIds.filter { it > 0 }.distinct()
+        if (ids.isEmpty()) throw SodaException("등록할 캐릭터 ID 리스트가 비어있습니다")
+        service.addCharacters(curationId, ids)
+        return ApiResponse.ok(true)
+    }
+
+    @DeleteMapping("/{curationId}/characters/{characterId}")
+    fun removeCharacter(
+        @PathVariable curationId: Long,
+        @PathVariable characterId: Long
+    ) = ApiResponse.ok(service.removeCharacter(curationId, characterId))
+
+    @PutMapping("/{curationId}/characters/reorder")
+    fun reorderCharacters(
+        @PathVariable curationId: Long,
+        @RequestBody request: CharacterCurationReorderCharactersRequest
+    ) = ApiResponse.ok(service.reorderCharacters(curationId, request.characterIds))
+}

src/main/kotlin/kr/co/vividnext/sodalive/admin/chat/character/curation/CharacterCurationAdminDto.kt

@@ -0,0 +1,45 @@
+package kr.co.vividnext.sodalive.admin.chat.character.curation
+
+data class CharacterCurationRegisterRequest(
+    val title: String,
+    val isAdult: Boolean = false,
+    val isActive: Boolean = true
+)
+
+data class CharacterCurationUpdateRequest(
+    val id: Long,
+    val title: String? = null,
+    val isAdult: Boolean? = null,
+    val isActive: Boolean? = null
+)
+
+data class CharacterCurationOrderUpdateRequest(
+    val ids: List<Long>
+)
+
+data class CharacterCurationAddCharacterRequest(
+    val characterIds: List<Long>
+)
+
+data class CharacterCurationReorderCharactersRequest(
+    val characterIds: List<Long>
+)
+
+data class CharacterCurationListItemResponse(
+    val id: Long,
+    val title: String,
+    val isAdult: Boolean,
+    val isActive: Boolean,
+    val characterCount: Int
+)
+
+// 관리자 큐레이션 상세 - 캐릭터 리스트 항목 응답 DTO
+// id, name, description, 이미지 URL
+// 이미지 URL은 컨트롤러에서 cloud-front host + imagePath로 구성
+
+data class CharacterCurationCharacterItemResponse(
+    val id: Long,
+    val name: String,
+    val description: String,
+    val imageUrl: String
+)

src/main/kotlin/kr/co/vividnext/sodalive/admin/chat/character/curation/CharacterCurationAdminService.kt

@@ -0,0 +1,153 @@
+package kr.co.vividnext.sodalive.admin.chat.character.curation
+
+import kr.co.vividnext.sodalive.chat.character.ChatCharacter
+import kr.co.vividnext.sodalive.chat.character.curation.CharacterCuration
+import kr.co.vividnext.sodalive.chat.character.curation.CharacterCurationMapping
+import kr.co.vividnext.sodalive.chat.character.curation.repository.CharacterCurationMappingRepository
+import kr.co.vividnext.sodalive.chat.character.curation.repository.CharacterCurationRepository
+import kr.co.vividnext.sodalive.chat.character.repository.ChatCharacterRepository
+import kr.co.vividnext.sodalive.common.SodaException
+import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
+
+@Service
+class CharacterCurationAdminService(
+    private val curationRepository: CharacterCurationRepository,
+    private val mappingRepository: CharacterCurationMappingRepository,
+    private val characterRepository: ChatCharacterRepository
+) {
+
+    @Transactional
+    fun register(request: CharacterCurationRegisterRequest): CharacterCuration {
+        val sortOrder = (curationRepository.findMaxSortOrder() ?: 0) + 1
+        val curation = CharacterCuration(
+            title = request.title,
+            isAdult = request.isAdult,
+            isActive = request.isActive,
+            sortOrder = sortOrder
+        )
+        return curationRepository.save(curation)
+    }
+
+    @Transactional
+    fun update(request: CharacterCurationUpdateRequest): CharacterCuration {
+        val curation = curationRepository.findById(request.id)
+            .orElseThrow { SodaException("큐레이션을 찾을 수 없습니다: ${request.id}") }
+
+        request.title?.let { curation.title = it }
+        request.isAdult?.let { curation.isAdult = it }
+        request.isActive?.let { curation.isActive = it }
+
+        return curationRepository.save(curation)
+    }
+
+    @Transactional
+    fun softDelete(curationId: Long) {
+        val curation = curationRepository.findById(curationId)
+            .orElseThrow { SodaException("큐레이션을 찾을 수 없습니다: $curationId") }
+        curation.isActive = false
+        curationRepository.save(curation)
+    }
+
+    @Transactional
+    fun reorder(ids: List<Long>) {
+        ids.forEachIndexed { index, id ->
+            val curation = curationRepository.findById(id)
+                .orElseThrow { SodaException("큐레이션을 찾을 수 없습니다: $id") }
+            curation.sortOrder = index + 1
+            curationRepository.save(curation)
+        }
+    }
+
+    @Transactional
+    fun addCharacters(curationId: Long, characterIds: List<Long>) {
+        if (characterIds.isEmpty()) throw SodaException("등록할 캐릭터 ID 리스트가 비어있습니다")
+
+        val curation = curationRepository.findById(curationId)
+            .orElseThrow { SodaException("큐레이션을 찾을 수 없습니다: $curationId") }
+        if (!curation.isActive) throw SodaException("비활성화된 큐레이션입니다: $curationId")
+
+        val uniqueIds = characterIds.filter { it > 0 }.distinct()
+        if (uniqueIds.isEmpty()) throw SodaException("유효한 캐릭터 ID가 없습니다")
+
+        // 활성 캐릭터만 조회 (조회 단계에서 검증 포함)
+        val characters = characterRepository.findByIdInAndIsActiveTrue(uniqueIds)
+        val characterMap = characters.associateBy { it.id!! }
+
+        // 조회 결과에 존재하는 캐릭터만 유효
+        val validIds = uniqueIds.filter { id -> characterMap.containsKey(id) }
+
+        val existingMappings = mappingRepository.findByCuration(curation)
+        val existingCharacterIds = existingMappings.mapNotNull { it.chatCharacter.id }.toSet()
+        var nextOrder = (existingMappings.maxOfOrNull { it.sortOrder } ?: 0) + 1
+
+        val toSave = mutableListOf<CharacterCurationMapping>()
+        validIds.forEach { id ->
+            if (!existingCharacterIds.contains(id)) {
+                val character = characterMap[id] ?: return@forEach
+                toSave += CharacterCurationMapping(
+                    curation = curation,
+                    chatCharacter = character,
+                    sortOrder = nextOrder++
+                )
+            }
+        }
+
+        if (toSave.isNotEmpty()) {
+            mappingRepository.saveAll(toSave)
+        }
+    }
+
+    @Transactional
+    fun removeCharacter(curationId: Long, characterId: Long) {
+        val curation = curationRepository.findById(curationId)
+            .orElseThrow { SodaException("큐레이션을 찾을 수 없습니다: $curationId") }
+        val mappings = mappingRepository.findByCuration(curation)
+        val target = mappings.firstOrNull { it.chatCharacter.id == characterId }
+            ?: throw SodaException("매핑을 찾을 수 없습니다: curation=$curationId, character=$characterId")
+        mappingRepository.delete(target)
+    }
+
+    @Transactional
+    fun reorderCharacters(curationId: Long, characterIds: List<Long>) {
+        val curation = curationRepository.findById(curationId)
+            .orElseThrow { SodaException("큐레이션을 찾을 수 없습니다: $curationId") }
+        val mappings = mappingRepository.findByCuration(curation)
+        val mappingByCharacterId = mappings.associateBy { it.chatCharacter.id }
+
+        characterIds.forEachIndexed { index, cid ->
+            val mapping = mappingByCharacterId[cid]
+                ?: throw SodaException("큐레이션에 포함되지 않은 캐릭터입니다: $cid")
+            mapping.sortOrder = index + 1
+            mappingRepository.save(mapping)
+        }
+    }
+
+    @Transactional(readOnly = true)
+    fun listAll(): List<CharacterCurationListItemResponse> {
+        val curations = curationRepository.findByIsActiveTrueOrderBySortOrderAsc()
+        if (curations.isEmpty()) return emptyList()
+
+        // DB 집계로 활성 캐릭터 수 카운트
+        val counts = mappingRepository.countActiveCharactersByCurations(curations)
+        val countByCurationId: Map<Long, Int> = counts.associate { it.curationId to it.count.toInt() }
+
+        return curations.map { curation ->
+            CharacterCurationListItemResponse(
+                id = curation.id!!,
+                title = curation.title,
+                isAdult = curation.isAdult,
+                isActive = curation.isActive,
+                characterCount = countByCurationId[curation.id!!] ?: 0
+            )
+        }
+    }
+
+    @Transactional(readOnly = true)
+    fun listCharacters(curationId: Long): List<ChatCharacter> {
+        val curation = curationRepository.findById(curationId)
+            .orElseThrow { SodaException("큐레이션을 찾을 수 없습니다: $curationId") }
+        val mappings = mappingRepository.findByCurationWithCharacterOrderBySortOrderAsc(curation)
+        return mappings.map { it.chatCharacter }
+    }
+}

src/main/kotlin/kr/co/vividnext/sodalive/admin/chat/character/dto/ChatCharacterDetailResponse.kt

@@ -0,0 +1,103 @@
+package kr.co.vividnext.sodalive.admin.chat.character.dto
+
+import kr.co.vividnext.sodalive.chat.character.ChatCharacter
+
+data class ChatCharacterDetailResponse(
+    val id: Long,
+    val characterUUID: String,
+    val name: String,
+    val imageUrl: String?,
+    val description: String,
+    val systemPrompt: String,
+    val characterType: String,
+    val age: Int?,
+    val gender: String?,
+    val mbti: String?,
+    val speechPattern: String?,
+    val speechStyle: String?,
+    val appearance: String?,
+    val isActive: Boolean,
+    val tags: List<String>,
+    val hobbies: List<String>,
+    val values: List<String>,
+    val goals: List<String>,
+    val relationships: List<RelationshipResponse>,
+    val personalities: List<PersonalityResponse>,
+    val backgrounds: List<BackgroundResponse>,
+    val memories: List<MemoryResponse>
+) {
+    companion object {
+        fun from(chatCharacter: ChatCharacter, imageHost: String = ""): ChatCharacterDetailResponse {
+            val fullImagePath = if (chatCharacter.imagePath != null && imageHost.isNotEmpty()) {
+                "$imageHost/${chatCharacter.imagePath}"
+            } else {
+                chatCharacter.imagePath ?: ""
+            }
+
+            return ChatCharacterDetailResponse(
+                id = chatCharacter.id!!,
+                characterUUID = chatCharacter.characterUUID,
+                name = chatCharacter.name,
+                imageUrl = fullImagePath,
+                description = chatCharacter.description,
+                systemPrompt = chatCharacter.systemPrompt,
+                characterType = chatCharacter.characterType.name,
+                age = chatCharacter.age,
+                gender = chatCharacter.gender,
+                mbti = chatCharacter.mbti,
+                speechPattern = chatCharacter.speechPattern,
+                speechStyle = chatCharacter.speechStyle,
+                appearance = chatCharacter.appearance,
+                isActive = chatCharacter.isActive,
+                tags = chatCharacter.tagMappings.map { it.tag.tag },
+                hobbies = chatCharacter.hobbyMappings.map { it.hobby.hobby },
+                values = chatCharacter.valueMappings.map { it.value.value },
+                goals = chatCharacter.goalMappings.map { it.goal.goal },
+                relationships = chatCharacter.relationships.map {
+                    RelationshipResponse(
+                        personName = it.personName,
+                        relationshipName = it.relationshipName,
+                        description = it.description,
+                        importance = it.importance,
+                        relationshipType = it.relationshipType,
+                        currentStatus = it.currentStatus
+                    )
+                },
+                personalities = chatCharacter.personalities.map {
+                    PersonalityResponse(it.trait, it.description)
+                },
+                backgrounds = chatCharacter.backgrounds.map {
+                    BackgroundResponse(it.topic, it.description)
+                },
+                memories = chatCharacter.memories.map {
+                    MemoryResponse(it.title, it.content, it.emotion)
+                }
+            )
+        }
+    }
+}
+
+data class PersonalityResponse(
+    val trait: String,
+    val description: String
+)
+
+data class BackgroundResponse(
+    val topic: String,
+    val description: String
+)
+
+data class MemoryResponse(
+    val title: String,
+    val content: String,
+    val emotion: String
+)
+
+data class RelationshipResponse(
+    val personName: String,
+    val relationshipName: String,
+    val description: String,
+    val importance: Int,
+    val relationshipType: String,
+    val currentStatus: String
+)

src/main/kotlin/kr/co/vividnext/sodalive/admin/chat/character/dto/ChatCharacterDto.kt

@@ -0,0 +1,88 @@
+package kr.co.vividnext.sodalive.admin.chat.character.dto
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties
+import com.fasterxml.jackson.annotation.JsonProperty
+
+data class ChatCharacterPersonalityRequest(
+    @JsonProperty("trait") val trait: String,
+    @JsonProperty("description") val description: String
+)
+
+data class ChatCharacterBackgroundRequest(
+    @JsonProperty("topic") val topic: String,
+    @JsonProperty("description") val description: String
+)
+
+data class ChatCharacterMemoryRequest(
+    @JsonProperty("title") val title: String,
+    @JsonProperty("content") val content: String,
+    @JsonProperty("emotion") val emotion: String
+)
+
+data class ChatCharacterRelationshipRequest(
+    @JsonProperty("personName") val personName: String,
+    @JsonProperty("relationshipName") val relationshipName: String,
+    @JsonProperty("description") val description: String,
+    @JsonProperty("importance") val importance: Int,
+    @JsonProperty("relationshipType") val relationshipType: String,
+    @JsonProperty("currentStatus") val currentStatus: String
+)
+
+data class ChatCharacterRegisterRequest(
+    @JsonProperty("name") val name: String,
+    @JsonProperty("systemPrompt") val systemPrompt: String,
+    @JsonProperty("description") val description: String,
+    @JsonProperty("age") val age: String?,
+    @JsonProperty("gender") val gender: String?,
+    @JsonProperty("mbti") val mbti: String?,
+    @JsonProperty("speechPattern") val speechPattern: String?,
+    @JsonProperty("speechStyle") val speechStyle: String?,
+    @JsonProperty("appearance") val appearance: String?,
+    @JsonProperty("originalTitle") val originalTitle: String? = null,
+    @JsonProperty("originalLink") val originalLink: String? = null,
+    @JsonProperty("characterType") val characterType: String? = null,
+    @JsonProperty("tags") val tags: List<String> = emptyList(),
+    @JsonProperty("hobbies") val hobbies: List<String> = emptyList(),
+    @JsonProperty("values") val values: List<String> = emptyList(),
+    @JsonProperty("goals") val goals: List<String> = emptyList(),
+    @JsonProperty("relationships") val relationships: List<ChatCharacterRelationshipRequest> = emptyList(),
+    @JsonProperty("personalities") val personalities: List<ChatCharacterPersonalityRequest> = emptyList(),
+    @JsonProperty("backgrounds") val backgrounds: List<ChatCharacterBackgroundRequest> = emptyList(),
+    @JsonProperty("memories") val memories: List<ChatCharacterMemoryRequest> = emptyList()
+)
+
+data class ExternalApiResponse(
+    @JsonProperty("success") val success: Boolean,
+    @JsonProperty("data") val data: ExternalApiData? = null,
+    @JsonProperty("message") val message: String? = null
+)
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+data class ExternalApiData(
+    @JsonProperty("id") val id: String
+)
+
+data class ChatCharacterUpdateRequest(
+    @JsonProperty("id") val id: Long,
+    @JsonProperty("name") val name: String? = null,
+    @JsonProperty("systemPrompt") val systemPrompt: String? = null,
+    @JsonProperty("description") val description: String? = null,
+    @JsonProperty("age") val age: String? = null,
+    @JsonProperty("gender") val gender: String? = null,
+    @JsonProperty("mbti") val mbti: String? = null,
+    @JsonProperty("speechPattern") val speechPattern: String? = null,
+    @JsonProperty("speechStyle") val speechStyle: String? = null,
+    @JsonProperty("appearance") val appearance: String? = null,
+    @JsonProperty("originalTitle") val originalTitle: String? = null,
+    @JsonProperty("originalLink") val originalLink: String? = null,
+    @JsonProperty("characterType") val characterType: String? = null,
+    @JsonProperty("isActive") val isActive: Boolean? = null,
+    @JsonProperty("tags") val tags: List<String>? = null,
+    @JsonProperty("hobbies") val hobbies: List<String>? = null,
+    @JsonProperty("values") val values: List<String>? = null,
+    @JsonProperty("goals") val goals: List<String>? = null,
+    @JsonProperty("relationships") val relationships: List<ChatCharacterRelationshipRequest>? = null,
+    @JsonProperty("personalities") val personalities: List<ChatCharacterPersonalityRequest>? = null,
+    @JsonProperty("backgrounds") val backgrounds: List<ChatCharacterBackgroundRequest>? = null,
+    @JsonProperty("memories") val memories: List<ChatCharacterMemoryRequest>? = null
+)

src/main/kotlin/kr/co/vividnext/sodalive/admin/chat/character/dto/ChatCharacterListResponse.kt

@@ -0,0 +1,62 @@
+package kr.co.vividnext.sodalive.admin.chat.character.dto
+
+import kr.co.vividnext.sodalive.chat.character.ChatCharacter
+import java.time.ZoneId
+import java.time.format.DateTimeFormatter
+
+data class ChatCharacterListResponse(
+    val id: Long,
+    val name: String,
+    val imageUrl: String?,
+    val description: String,
+    val gender: String?,
+    val age: Int?,
+    val mbti: String?,
+    val speechStyle: String?,
+    val speechPattern: String?,
+    val tags: List<String>,
+    val createdAt: String?,
+    val updatedAt: String?
+) {
+    companion object {
+        private val formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")
+        private val seoulZoneId = ZoneId.of("Asia/Seoul")
+
+        fun from(chatCharacter: ChatCharacter, imageHost: String = ""): ChatCharacterListResponse {
+            val fullImagePath = if (chatCharacter.imagePath != null && imageHost.isNotEmpty()) {
+                "$imageHost/${chatCharacter.imagePath}"
+            } else {
+                chatCharacter.imagePath
+            }
+
+            // UTC에서 Asia/Seoul로 시간대 변환 및 문자열 포맷팅
+            val createdAtStr = chatCharacter.createdAt?.atZone(ZoneId.of("UTC"))
+                ?.withZoneSameInstant(seoulZoneId)
+                ?.format(formatter)
+
+            val updatedAtStr = chatCharacter.updatedAt?.atZone(ZoneId.of("UTC"))
+                ?.withZoneSameInstant(seoulZoneId)
+                ?.format(formatter)
+
+            return ChatCharacterListResponse(
+                id = chatCharacter.id!!,
+                name = chatCharacter.name,
+                imageUrl = fullImagePath,
+                description = chatCharacter.description,
+                gender = chatCharacter.gender,
+                age = chatCharacter.age,
+                mbti = chatCharacter.mbti,
+                speechStyle = chatCharacter.speechStyle,
+                speechPattern = chatCharacter.speechPattern,
+                tags = chatCharacter.tagMappings.map { it.tag.tag },
+                createdAt = createdAtStr,
+                updatedAt = updatedAtStr
+            )
+        }
+    }
+}
+
+data class ChatCharacterListPageResponse(
+    val totalCount: Long,
+    val content: List<ChatCharacterListResponse>
+)

src/main/kotlin/kr/co/vividnext/sodalive/admin/chat/character/dto/ChatCharacterSearchResponse.kt

@@ -0,0 +1,30 @@
+package kr.co.vividnext.sodalive.admin.chat.character.dto
+
+import kr.co.vividnext.sodalive.chat.character.ChatCharacter
+
+/**
+ * 캐릭터 검색 결과 응답 DTO
+ */
+data class ChatCharacterSearchResponse(
+    val id: Long,
+    val name: String,
+    val imagePath: String?
+) {
+    companion object {
+        fun from(character: ChatCharacter, imageHost: String): ChatCharacterSearchResponse {
+            return ChatCharacterSearchResponse(
+                id = character.id!!,
+                name = character.name,
+                imagePath = character.imagePath?.let { "$imageHost/$it" }
+            )
+        }
+    }
+}
+
+/**
+ * 캐릭터 검색 결과 페이지 응답 DTO
+ */
+data class ChatCharacterSearchListPageResponse(
+    val totalCount: Long,
+    val content: List<ChatCharacterSearchResponse>
+)

src/main/kotlin/kr/co/vividnext/sodalive/admin/chat/character/image/AdminCharacterImageController.kt

@@ -0,0 +1,170 @@
+package kr.co.vividnext.sodalive.admin.chat.character.image
+
+import com.amazonaws.services.s3.model.ObjectMetadata
+import com.fasterxml.jackson.databind.ObjectMapper
+import kr.co.vividnext.sodalive.admin.chat.character.image.dto.AdminCharacterImageResponse
+import kr.co.vividnext.sodalive.admin.chat.character.image.dto.RegisterCharacterImageRequest
+import kr.co.vividnext.sodalive.admin.chat.character.image.dto.UpdateCharacterImageOrdersRequest
+import kr.co.vividnext.sodalive.admin.chat.character.image.dto.UpdateCharacterImageTriggersRequest
+import kr.co.vividnext.sodalive.aws.cloudfront.ImageContentCloudFront
+import kr.co.vividnext.sodalive.aws.s3.S3Uploader
+import kr.co.vividnext.sodalive.chat.character.image.CharacterImageService
+import kr.co.vividnext.sodalive.common.ApiResponse
+import kr.co.vividnext.sodalive.common.SodaException
+import kr.co.vividnext.sodalive.utils.ImageBlurUtil
+import kr.co.vividnext.sodalive.utils.generateFileName
+import org.springframework.beans.factory.annotation.Value
+import org.springframework.security.access.prepost.PreAuthorize
+import org.springframework.web.bind.annotation.DeleteMapping
+import org.springframework.web.bind.annotation.GetMapping
+import org.springframework.web.bind.annotation.PathVariable
+import org.springframework.web.bind.annotation.PostMapping
+import org.springframework.web.bind.annotation.PutMapping
+import org.springframework.web.bind.annotation.RequestBody
+import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RequestParam
+import org.springframework.web.bind.annotation.RequestPart
+import org.springframework.web.bind.annotation.RestController
+import org.springframework.web.multipart.MultipartFile
+
+@RestController
+@RequestMapping("/admin/chat/character/image")
+@PreAuthorize("hasRole('ADMIN')")
+class AdminCharacterImageController(
+    private val imageService: CharacterImageService,
+    private val s3Uploader: S3Uploader,
+    private val imageCloudFront: ImageContentCloudFront,
+
+    @Value("\${cloud.aws.s3.content-bucket}")
+    private val s3Bucket: String,
+
+    @Value("\${cloud.aws.s3.bucket}")
+    private val freeBucket: String
+) {
+
+    @GetMapping("/list")
+    fun list(@RequestParam characterId: Long) = run {
+        val expiration = 5L * 60L * 1000L // 5분
+        val list = imageService.listActiveByCharacter(characterId)
+            .map { img ->
+                val signedUrl = imageCloudFront.generateSignedURL(img.imagePath, expiration)
+                AdminCharacterImageResponse.fromWithUrl(img, signedUrl)
+            }
+        ApiResponse.ok(list)
+    }
+
+    @GetMapping("/{imageId}")
+    fun detail(@PathVariable imageId: Long) = run {
+        val img = imageService.getById(imageId)
+        val expiration = 5L * 60L * 1000L // 5분
+        val signedUrl = imageCloudFront.generateSignedURL(img.imagePath, expiration)
+        ApiResponse.ok(AdminCharacterImageResponse.fromWithUrl(img, signedUrl))
+    }
+
+    @PostMapping("/register")
+    fun register(
+        @RequestPart("image") image: MultipartFile,
+        @RequestPart("request") requestString: String
+    ) = run {
+        val objectMapper = ObjectMapper()
+        val request = objectMapper.readValue(requestString, RegisterCharacterImageRequest::class.java)
+
+        // 업로드 키 생성
+        val s3Key = buildS3Key(characterId = request.characterId)
+
+        // 원본 저장 (content-bucket)
+        val imagePath = saveImageToBucket(s3Key, image, s3Bucket)
+
+        // 블러 생성 및 저장 (무료 이미지 버킷)
+        val blurImagePath = saveBlurImageToBucket(s3Key, image, freeBucket)
+
+        imageService.registerImage(
+            characterId = request.characterId,
+            imagePath = imagePath,
+            blurImagePath = blurImagePath,
+            imagePriceCan = request.imagePriceCan,
+            messagePriceCan = request.messagePriceCan,
+            isAdult = request.isAdult,
+            triggers = request.triggers ?: emptyList()
+        )
+
+        ApiResponse.ok(null)
+    }
+
+    @PutMapping("/{imageId}/triggers")
+    fun updateTriggers(
+        @PathVariable imageId: Long,
+        @RequestBody request: UpdateCharacterImageTriggersRequest
+    ) = run {
+        if (!request.triggers.isNullOrEmpty()) {
+            imageService.updateTriggers(imageId, request.triggers)
+        }
+
+        ApiResponse.ok(null)
+    }
+
+    @DeleteMapping("/{imageId}")
+    fun delete(@PathVariable imageId: Long) = run {
+        imageService.deleteImage(imageId)
+        ApiResponse.ok(null, "이미지가 삭제되었습니다.")
+    }
+
+    @PutMapping("/orders")
+    fun updateOrders(@RequestBody request: UpdateCharacterImageOrdersRequest) = run {
+        if (request.characterId == null) throw SodaException("characterId는 필수입니다")
+        imageService.updateOrders(request.characterId, request.ids)
+        ApiResponse.ok(null, "정렬 순서가 변경되었습니다.")
+    }
+
+    private fun buildS3Key(characterId: Long): String {
+        val fileName = generateFileName("character-image")
+        return "characters/$characterId/images/$fileName"
+    }
+
+    private fun saveImageToBucket(filePath: String, image: MultipartFile, bucket: String): String {
+        try {
+            val metadata = ObjectMetadata()
+            metadata.contentLength = image.size
+            return s3Uploader.upload(
+                inputStream = image.inputStream,
+                bucket = bucket,
+                filePath = filePath,
+                metadata = metadata
+            )
+        } catch (e: Exception) {
+            throw SodaException("이미지 저장에 실패했습니다: ${e.message}")
+        }
+    }
+
+    private fun saveBlurImageToBucket(filePath: String, image: MultipartFile, bucket: String): String {
+        try {
+            // 멀티파트를 BufferedImage로 읽기
+            val bytes = image.bytes
+            val bimg = javax.imageio.ImageIO.read(java.io.ByteArrayInputStream(bytes))
+                ?: throw SodaException("이미지 포맷을 인식할 수 없습니다.")
+            val blurred = ImageBlurUtil.blurFast(bimg)
+
+            // PNG로 저장(알파 유지), JPEG 업로드가 필요하면 포맷 변경 가능
+            val baos = java.io.ByteArrayOutputStream()
+            val format = when (image.contentType?.lowercase()) {
+                "image/png" -> "png"
+                else -> "jpg"
+            }
+            javax.imageio.ImageIO.write(blurred, format, baos)
+            val inputStream = java.io.ByteArrayInputStream(baos.toByteArray())
+
+            val metadata = ObjectMetadata()
+            metadata.contentLength = baos.size().toLong()
+            metadata.contentType = image.contentType ?: if (format == "png") "image/png" else "image/jpeg"
+
+            return s3Uploader.upload(
+                inputStream = inputStream,
+                bucket = bucket,
+                filePath = filePath,
+                metadata = metadata
+            )
+        } catch (e: Exception) {
+            throw SodaException("블러 이미지 저장에 실패했습니다: ${e.message}")
+        }
+    }
+}

src/main/kotlin/kr/co/vividnext/sodalive/admin/chat/character/image/dto/CharacterImageDtos.kt

@@ -0,0 +1,53 @@
+package kr.co.vividnext.sodalive.admin.chat.character.image.dto
+
+import com.fasterxml.jackson.annotation.JsonProperty
+import kr.co.vividnext.sodalive.chat.character.image.CharacterImage
+
+// 요청 DTOs
+
+data class RegisterCharacterImageRequest(
+    @JsonProperty("characterId") val characterId: Long,
+    @JsonProperty("imagePriceCan") val imagePriceCan: Long,
+    @JsonProperty("messagePriceCan") val messagePriceCan: Long,
+    @JsonProperty("isAdult") val isAdult: Boolean = false,
+    @JsonProperty("triggers") val triggers: List<String>? = null
+)
+
+data class UpdateCharacterImageTriggersRequest(
+    @JsonProperty("triggers") val triggers: List<String>? = null
+)
+
+data class UpdateCharacterImageOrdersRequest(
+    @JsonProperty("characterId") val characterId: Long?,
+    @JsonProperty("ids") val ids: List<Long>
+)
+
+// 응답 DTOs
+
+data class AdminCharacterImageResponse(
+    val id: Long,
+    val characterId: Long,
+    val imagePriceCan: Long,
+    val messagePriceCan: Long,
+    val imageUrl: String,
+    val triggers: List<String>,
+    val isAdult: Boolean
+) {
+    companion object {
+        fun fromWithUrl(entity: CharacterImage, signedUrl: String): AdminCharacterImageResponse {
+            return base(entity, signedUrl)
+        }
+
+        private fun base(entity: CharacterImage, url: String): AdminCharacterImageResponse {
+            return AdminCharacterImageResponse(
+                id = entity.id!!,
+                characterId = entity.chatCharacter.id!!,
+                imagePriceCan = entity.imagePriceCan,
+                messagePriceCan = entity.messagePriceCan,
+                imageUrl = url,
+                triggers = entity.triggerMappings.map { it.tag.word },
+                isAdult = entity.isAdult
+            )
+        }
+    }
+}

src/main/kotlin/kr/co/vividnext/sodalive/admin/chat/character/service/AdminChatCharacterService.kt

@@ -0,0 +1,84 @@
+package kr.co.vividnext.sodalive.admin.chat.character.service
+
+import kr.co.vividnext.sodalive.admin.chat.character.dto.ChatCharacterDetailResponse
+import kr.co.vividnext.sodalive.admin.chat.character.dto.ChatCharacterListPageResponse
+import kr.co.vividnext.sodalive.admin.chat.character.dto.ChatCharacterListResponse
+import kr.co.vividnext.sodalive.admin.chat.character.dto.ChatCharacterSearchResponse
+import kr.co.vividnext.sodalive.chat.character.repository.ChatCharacterRepository
+import kr.co.vividnext.sodalive.common.SodaException
+import org.springframework.data.domain.Page
+import org.springframework.data.domain.PageRequest
+import org.springframework.data.domain.Pageable
+import org.springframework.data.domain.Sort
+import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
+
+@Service
+class AdminChatCharacterService(
+    private val chatCharacterRepository: ChatCharacterRepository
+) {
+    /**
+     * 활성화된 캐릭터 목록을 페이징하여 조회
+     *
+     * @param pageable 페이징 정보
+     * @return 페이징된 캐릭터 목록
+     */
+    @Transactional(readOnly = true)
+    fun getActiveChatCharacters(pageable: Pageable, imageHost: String = ""): ChatCharacterListPageResponse {
+        // isActive가 true인 캐릭터만 조회
+        val page = chatCharacterRepository.findByIsActiveTrue(pageable)
+
+        // 페이지 정보 생성
+        val content = page.content.map { ChatCharacterListResponse.from(it, imageHost) }
+
+        return ChatCharacterListPageResponse(
+            totalCount = page.totalElements,
+            content = content
+        )
+    }
+
+    /**
+     * 기본 페이지 요청 생성
+     *
+     * @param page 페이지 번호 (0부터 시작)
+     * @param size 페이지 크기
+     * @return 페이지 요청 객체
+     */
+    fun createDefaultPageRequest(page: Int = 0, size: Int = 20): PageRequest {
+        return PageRequest.of(page, size, Sort.by(Sort.Direction.DESC, "createdAt"))
+    }
+
+    /**
+     * 캐릭터 상세 정보 조회
+     *
+     * @param characterId 캐릭터 ID
+     * @param imageHost 이미지 호스트 URL
+     * @return 캐릭터 상세 정보
+     * @throws SodaException 캐릭터를 찾을 수 없는 경우
+     */
+    @Transactional(readOnly = true)
+    fun getChatCharacterDetail(characterId: Long, imageHost: String = ""): ChatCharacterDetailResponse {
+        val chatCharacter = chatCharacterRepository.findById(characterId)
+            .orElseThrow { SodaException("해당 ID의 캐릭터를 찾을 수 없습니다: $characterId") }
+
+        return ChatCharacterDetailResponse.from(chatCharacter, imageHost)
+    }
+
+    /**
+     * 캐릭터 검색 (이름, 설명, MBTI, 태그 기반)
+     *
+     * @param searchTerm 검색어
+     * @param pageable 페이징 정보
+     * @param imageHost 이미지 호스트 URL
+     * @return 검색된 캐릭터 목록 (페이징)
+     */
+    @Transactional(readOnly = true)
+    fun searchCharacters(
+        searchTerm: String,
+        pageable: Pageable,
+        imageHost: String = ""
+    ): Page<ChatCharacterSearchResponse> {
+        val characters = chatCharacterRepository.searchCharacters(searchTerm, pageable)
+        return characters.map { ChatCharacterSearchResponse.from(it, imageHost) }
+    }
+}

src/main/kotlin/kr/co/vividnext/sodalive/admin/chat/dto/ChatCharacterBannerRequest.kt

@@ -0,0 +1,30 @@
+package kr.co.vividnext.sodalive.admin.chat.dto
+
+import com.fasterxml.jackson.annotation.JsonProperty
+
+/**
+ * 캐릭터 배너 등록 요청 DTO
+ */
+data class ChatCharacterBannerRegisterRequest(
+    // 캐릭터 ID
+    @JsonProperty("characterId") val characterId: Long
+)
+
+/**
+ * 캐릭터 배너 수정 요청 DTO
+ */
+data class ChatCharacterBannerUpdateRequest(
+    // 배너 ID
+    @JsonProperty("bannerId") val bannerId: Long,
+
+    // 캐릭터 ID (변경할 캐릭터)
+    @JsonProperty("characterId") val characterId: Long? = null
+)
+
+/**
+ * 캐릭터 배너 정렬 순서 일괄 변경 요청 DTO
+ */
+data class UpdateBannerOrdersRequest(
+    // 배너 ID 목록 (순서대로 정렬됨)
+    @JsonProperty("ids") val ids: List<Long>
+)

src/main/kotlin/kr/co/vividnext/sodalive/admin/chat/dto/ChatCharacterBannerResponse.kt

@@ -0,0 +1,32 @@
+package kr.co.vividnext.sodalive.admin.chat.dto
+
+import kr.co.vividnext.sodalive.chat.character.ChatCharacterBanner
+
+/**
+ * 캐릭터 배너 응답 DTO
+ */
+data class ChatCharacterBannerResponse(
+    val id: Long,
+    val imagePath: String,
+    val characterId: Long,
+    val characterName: String
+) {
+    companion object {
+        fun from(banner: ChatCharacterBanner, imageHost: String): ChatCharacterBannerResponse {
+            return ChatCharacterBannerResponse(
+                id = banner.id!!,
+                imagePath = "$imageHost/${banner.imagePath}",
+                characterId = banner.chatCharacter.id!!,
+                characterName = banner.chatCharacter.name
+            )
+        }
+    }
+}
+
+/**
+ * 캐릭터 배너 목록 페이지 응답 DTO
+ */
+data class ChatCharacterBannerListPageResponse(
+    val totalCount: Long,
+    val content: List<ChatCharacterBannerResponse>
+)

src/main/kotlin/kr/co/vividnext/sodalive/aws/cloudfront/ImageContentCloudFront.kt

@@ -0,0 +1,48 @@
+package kr.co.vividnext.sodalive.aws.cloudfront
+
+import com.amazonaws.services.cloudfront.CloudFrontUrlSigner
+import org.springframework.beans.factory.annotation.Value
+import org.springframework.stereotype.Component
+import java.nio.file.Files
+import java.nio.file.Paths
+import java.security.KeyFactory
+import java.security.PrivateKey
+import java.security.spec.PKCS8EncodedKeySpec
+import java.util.Date
+
+/**
+ * 이미지(CloudFront) 서명 URL 생성기
+ * - cloud.aws.cloud-front.* 설정을 사용
+ */
+@Component
+class ImageContentCloudFront(
+    @Value("\${cloud.aws.content-cloud-front.host}")
+    private val cloudfrontDomain: String,
+
+    @Value("\${cloud.aws.content-cloud-front.private-key-file-path}")
+    private val privateKeyFilePath: String,
+
+    @Value("\${cloud.aws.content-cloud-front.key-pair-id}")
+    private val keyPairId: String
+) {
+    fun generateSignedURL(
+        resourcePath: String,
+        expirationTimeMillis: Long
+    ): String {
+        val privateKey = loadPrivateKey(privateKeyFilePath)
+        return CloudFrontUrlSigner.getSignedURLWithCannedPolicy(
+            "$cloudfrontDomain/$resourcePath",
+            keyPairId,
+            privateKey,
+            Date(System.currentTimeMillis() + expirationTimeMillis)
+        )
+    }
+
+    private fun loadPrivateKey(resourceName: String): PrivateKey {
+        val path = Paths.get(resourceName)
+        val bytes = Files.readAllBytes(path)
+        val keySpec = PKCS8EncodedKeySpec(bytes)
+        val keyFactory = KeyFactory.getInstance("RSA")
+        return keyFactory.generatePrivate(keySpec)
+    }
+}

src/main/kotlin/kr/co/vividnext/sodalive/can/CanService.kt

@@ -72,6 +72,10 @@ class CanService(private val repository: CanRepository) {
                     CanUsage.ORDER_CONTENT -> "[콘텐츠 구매] ${it.audioContent!!.title}"
                     CanUsage.PAID_COMMUNITY_POST -> "[게시글 보기] ${it.communityPost?.member?.nickname ?: ""}"
                     CanUsage.AUDITION_VOTE -> "[오디션 투표] ${it.auditionApplicant?.role?.audition?.title ?: ""}"
+                    CanUsage.CHAT_MESSAGE_PURCHASE -> "[메시지 구매] ${it.characterImage?.chatCharacter?.name ?: ""}"
+                    CanUsage.CHARACTER_IMAGE_PURCHASE -> "[캐릭터 이미지 구매] ${it.characterImage?.chatCharacter?.name ?: ""}"
+                    CanUsage.CHAT_QUOTA_PURCHASE -> "캐릭터 톡 이용권 구매"
+                    CanUsage.CHAT_ROOM_RESET -> "캐릭터 톡 초기화"
                 }
 
                 val createdAt = it.createdAt!!

src/main/kotlin/kr/co/vividnext/sodalive/can/payment/CanPaymentService.kt

@@ -13,6 +13,7 @@ import kr.co.vividnext.sodalive.can.use.UseCanCalculate
 import kr.co.vividnext.sodalive.can.use.UseCanCalculateRepository
 import kr.co.vividnext.sodalive.can.use.UseCanCalculateStatus
 import kr.co.vividnext.sodalive.can.use.UseCanRepository
+import kr.co.vividnext.sodalive.chat.character.image.CharacterImage
 import kr.co.vividnext.sodalive.common.SodaException
 import kr.co.vividnext.sodalive.content.AudioContent
 import kr.co.vividnext.sodalive.content.order.Order
@@ -37,6 +38,8 @@ class CanPaymentService(
         memberId: Long,
         needCan: Int,
         canUsage: CanUsage,
+        chatRoomId: Long? = null,
+        characterId: Long? = null,
         isSecret: Boolean = false,
         liveRoom: LiveRoom? = null,
         order: Order? = null,
@@ -109,6 +112,14 @@ class CanPaymentService(
             recipientId = liveRoom.member!!.id!!
             useCan.room = liveRoom
             useCan.member = member
+        } else if (canUsage == CanUsage.CHAT_QUOTA_PURCHASE && chatRoomId != null && characterId != null) {
+            useCan.member = member
+            useCan.chatRoomId = chatRoomId
+            useCan.characterId = characterId
+        } else if (canUsage == CanUsage.CHAT_ROOM_RESET) {
+            useCan.member = member
+            useCan.chatRoomId = chatRoomId
+            useCan.characterId = characterId
         } else {
             throw SodaException("잘못된 요청입니다.")
         }
@@ -327,4 +338,98 @@ class CanPaymentService(
             chargeRepository.save(charge)
         }
     }
+
+    @Transactional
+    fun spendCanForCharacterImage(
+        memberId: Long,
+        needCan: Int,
+        image: CharacterImage,
+        container: String
+    ) {
+        val member = memberRepository.findByIdOrNull(id = memberId)
+            ?: throw SodaException("잘못된 요청입니다.\n다시 시도해 주세요.")
+
+        val useRewardCan = spendRewardCan(member, needCan, container)
+        val useChargeCan = if (needCan - useRewardCan.total > 0) {
+            spendChargeCan(member, needCan = needCan - useRewardCan.total, container = container)
+        } else {
+            null
+        }
+
+        if (needCan - useRewardCan.total - (useChargeCan?.total ?: 0) > 0) {
+            throw SodaException(
+                "${needCan - useRewardCan.total - (useChargeCan?.total ?: 0)} " +
+                    "캔이 부족합니다. 충전 후 이용해 주세요."
+            )
+        }
+
+        if (!useRewardCan.verify() || useChargeCan?.verify() == false) {
+            throw SodaException("잘못된 요청입니다.\n다시 시도해 주세요.")
+        }
+
+        val useCan = UseCan(
+            canUsage = CanUsage.CHARACTER_IMAGE_PURCHASE,
+            can = useChargeCan?.total ?: 0,
+            rewardCan = useRewardCan.total,
+            isSecret = false
+        )
+        useCan.member = member
+        useCan.characterImage = image
+
+        useCanRepository.save(useCan)
+
+        setUseCanCalculate(null, useRewardCan, useChargeCan, useCan, paymentGateway = PaymentGateway.PG)
+        setUseCanCalculate(null, useRewardCan, useChargeCan, useCan, paymentGateway = PaymentGateway.POINT_CLICK_AD)
+        setUseCanCalculate(null, useRewardCan, useChargeCan, useCan, paymentGateway = PaymentGateway.GOOGLE_IAP)
+        setUseCanCalculate(null, useRewardCan, useChargeCan, useCan, paymentGateway = PaymentGateway.APPLE_IAP)
+    }
+
+    @Transactional
+    fun spendCanForChatMessage(
+        memberId: Long,
+        needCan: Int,
+        message: kr.co.vividnext.sodalive.chat.room.ChatMessage,
+        container: String
+    ) {
+        val member = memberRepository.findByIdOrNull(id = memberId)
+            ?: throw SodaException("잘못된 요청입니다.\n다시 시도해 주세요.")
+
+        val useRewardCan = spendRewardCan(member, needCan, container)
+        val useChargeCan = if (needCan - useRewardCan.total > 0) {
+            spendChargeCan(member, needCan = needCan - useRewardCan.total, container = container)
+        } else {
+            null
+        }
+
+        if (needCan - useRewardCan.total - (useChargeCan?.total ?: 0) > 0) {
+            throw SodaException(
+                "${needCan - useRewardCan.total - (useChargeCan?.total ?: 0)} " +
+                    "캔이 부족합니다. 충전 후 이용해 주세요."
+            )
+        }
+
+        if (!useRewardCan.verify() || useChargeCan?.verify() == false) {
+            throw SodaException("잘못된 요청입니다.\n다시 시도해 주세요.")
+        }
+
+        val useCan = UseCan(
+            canUsage = CanUsage.CHAT_MESSAGE_PURCHASE,
+            can = useChargeCan?.total ?: 0,
+            rewardCan = useRewardCan.total,
+            isSecret = false
+        )
+        useCan.member = member
+        useCan.chatMessage = message
+        // 이미지 메시지의 경우 이미지 연관도 함께 기록
+        message.characterImage?.let { img ->
+            useCan.characterImage = img
+        }
+
+        useCanRepository.save(useCan)
+
+        setUseCanCalculate(null, useRewardCan, useChargeCan, useCan, paymentGateway = PaymentGateway.PG)
+        setUseCanCalculate(null, useRewardCan, useChargeCan, useCan, paymentGateway = PaymentGateway.POINT_CLICK_AD)
+        setUseCanCalculate(null, useRewardCan, useChargeCan, useCan, paymentGateway = PaymentGateway.GOOGLE_IAP)
+        setUseCanCalculate(null, useRewardCan, useChargeCan, useCan, paymentGateway = PaymentGateway.APPLE_IAP)
+    }
 }

src/main/kotlin/kr/co/vividnext/sodalive/can/use/CanUsage.kt

@@ -9,5 +9,9 @@ enum class CanUsage {
     SPIN_ROULETTE,
     PAID_COMMUNITY_POST,
     ALARM_SLOT,
-    AUDITION_VOTE
+    AUDITION_VOTE,
+    CHAT_MESSAGE_PURCHASE, // 메시지를 통한 구매(이미지 등 다양한 리소스에 공통 적용)
+    CHARACTER_IMAGE_PURCHASE, // 캐릭터 이미지 단독 구매
+    CHAT_QUOTA_PURCHASE, // 채팅 횟수(쿼터) 충전
+    CHAT_ROOM_RESET // 채팅방 초기화 결제(별도 구분)
 }

src/main/kotlin/kr/co/vividnext/sodalive/can/use/UseCan.kt

@@ -1,6 +1,8 @@
 package kr.co.vividnext.sodalive.can.use
 
 import kr.co.vividnext.sodalive.audition.AuditionApplicant
+import kr.co.vividnext.sodalive.chat.character.image.CharacterImage
+import kr.co.vividnext.sodalive.chat.room.ChatMessage
 import kr.co.vividnext.sodalive.common.BaseEntity
 import kr.co.vividnext.sodalive.content.AudioContent
 import kr.co.vividnext.sodalive.content.order.Order
@@ -28,7 +30,11 @@ data class UseCan(
 
     var isRefund: Boolean = false,
 
-    val isSecret: Boolean = false
+    val isSecret: Boolean = false,
+
+    // 채팅 연동을 위한 식별자 (옵션)
+    var chatRoomId: Long? = null,
+    var characterId: Long? = null
 ) : BaseEntity() {
     @ManyToOne(fetch = FetchType.LAZY)
     @JoinColumn(name = "member_id", nullable = false)
@@ -58,6 +64,16 @@ data class UseCan(
     @JoinColumn(name = "audition_applicant_id", nullable = true)
     var auditionApplicant: AuditionApplicant? = null
 
+    // 메시지를 통한 구매 연관 (옵션)
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "chat_message_id", nullable = true)
+    var chatMessage: ChatMessage? = null
+
+    // 캐릭터 이미지 연관 (메시지 구매/단독 구매 공통 사용)
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "character_image_id", nullable = true)
+    var characterImage: CharacterImage? = null
+
     @OneToMany(mappedBy = "useCan", cascade = [CascadeType.ALL])
     val useCanCalculates: MutableList<UseCanCalculate> = mutableListOf()
 }

src/main/kotlin/kr/co/vividnext/sodalive/can/use/UseCanRepository.kt

@@ -6,10 +6,22 @@ import org.springframework.data.jpa.repository.JpaRepository
 import org.springframework.stereotype.Repository
 
 @Repository
-interface UseCanRepository : JpaRepository<UseCan, Long>, UseCanQueryRepository
+interface UseCanRepository : JpaRepository<UseCan, Long>, UseCanQueryRepository {
+    // 특정 멤버가 해당 이미지에 대해 구매 이력이 있는지(환불 제외)
+    fun existsByMember_IdAndIsRefundFalseAndCharacterImage_IdAndCanUsageIn(
+        memberId: Long,
+        imageId: Long,
+        usages: Collection<CanUsage>
+    ): Boolean
+}
 
 interface UseCanQueryRepository {
     fun isExistCommunityPostOrdered(postId: Long, memberId: Long): Boolean
+    fun countPurchasedActiveImagesByCharacter(
+        memberId: Long,
+        characterId: Long,
+        usages: Collection<CanUsage>
+    ): Long
 }
 
 class UseCanQueryRepositoryImpl(private val queryFactory: JPAQueryFactory) : UseCanQueryRepository {
@@ -26,4 +38,24 @@ class UseCanQueryRepositoryImpl(private val queryFactory: JPAQueryFactory) : Use
 
         return useCanId != null && useCanId > 0
     }
+
+    override fun countPurchasedActiveImagesByCharacter(
+        memberId: Long,
+        characterId: Long,
+        usages: Collection<CanUsage>
+    ): Long {
+        val count = queryFactory
+            .selectDistinct(useCan.characterImage.id)
+            .from(useCan)
+            .where(
+                useCan.member.id.eq(memberId)
+                    .and(useCan.isRefund.isFalse)
+                    .and(useCan.characterImage.chatCharacter.id.eq(characterId))
+                    .and(useCan.characterImage.isActive.isTrue)
+                    .and(useCan.canUsage.`in`(usages))
+            )
+            .fetch()
+            .size
+        return count.toLong()
+    }
 }

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/ChatCharacter.kt

@@ -0,0 +1,155 @@
+package kr.co.vividnext.sodalive.chat.character
+
+import kr.co.vividnext.sodalive.common.BaseEntity
+import javax.persistence.CascadeType
+import javax.persistence.Column
+import javax.persistence.Entity
+import javax.persistence.EnumType
+import javax.persistence.Enumerated
+import javax.persistence.FetchType
+import javax.persistence.OneToMany
+
+@Entity
+class ChatCharacter(
+    val characterUUID: String,
+
+    // 캐릭터 이름 (API 키 내에서 유일해야 함)
+    var name: String,
+
+    // 캐릭터 한 줄 소개
+    var description: String,
+
+    // AI 시스템 프롬프트
+    @Column(columnDefinition = "TEXT", nullable = false)
+    var systemPrompt: String,
+
+    // 나이
+    var age: Int? = null,
+
+    // 성별
+    var gender: String? = null,
+
+    // mbti
+    var mbti: String? = null,
+
+    // 말투 패턴 설명
+    @Column(columnDefinition = "TEXT")
+    var speechPattern: String? = null,
+
+    // 대화 스타일
+    @Column(columnDefinition = "TEXT")
+    var speechStyle: String? = null,
+
+    // 외모 설명
+    @Column(columnDefinition = "TEXT")
+    var appearance: String? = null,
+
+    // 원작 (optional)
+    @Column(nullable = true)
+    var originalTitle: String? = null,
+
+    // 원작 링크 (optional)
+    @Column(nullable = true)
+    var originalLink: String? = null,
+
+    // 캐릭터 유형
+    @Enumerated(EnumType.STRING)
+    @Column(nullable = false)
+    var characterType: CharacterType = CharacterType.Character,
+
+    var isActive: Boolean = true
+) : BaseEntity() {
+    var imagePath: String? = null
+
+    @OneToMany(mappedBy = "chatCharacter", cascade = [CascadeType.ALL], fetch = FetchType.LAZY, orphanRemoval = true)
+    var memories: MutableList<ChatCharacterMemory> = mutableListOf()
+
+    @OneToMany(mappedBy = "chatCharacter", cascade = [CascadeType.ALL], fetch = FetchType.LAZY, orphanRemoval = true)
+    var personalities: MutableList<ChatCharacterPersonality> = mutableListOf()
+
+    @OneToMany(mappedBy = "chatCharacter", cascade = [CascadeType.ALL], fetch = FetchType.LAZY, orphanRemoval = true)
+    var backgrounds: MutableList<ChatCharacterBackground> = mutableListOf()
+
+    @OneToMany(mappedBy = "chatCharacter", cascade = [CascadeType.ALL], fetch = FetchType.LAZY, orphanRemoval = true)
+    var relationships: MutableList<ChatCharacterRelationship> = mutableListOf()
+
+    @OneToMany(mappedBy = "chatCharacter", cascade = [CascadeType.ALL], fetch = FetchType.LAZY, orphanRemoval = true)
+    var tagMappings: MutableList<ChatCharacterTagMapping> = mutableListOf()
+
+    @OneToMany(mappedBy = "chatCharacter", cascade = [CascadeType.ALL], fetch = FetchType.LAZY, orphanRemoval = true)
+    var valueMappings: MutableList<ChatCharacterValueMapping> = mutableListOf()
+
+    @OneToMany(mappedBy = "chatCharacter", cascade = [CascadeType.ALL], fetch = FetchType.LAZY, orphanRemoval = true)
+    var hobbyMappings: MutableList<ChatCharacterHobbyMapping> = mutableListOf()
+
+    @OneToMany(mappedBy = "chatCharacter", cascade = [CascadeType.ALL], fetch = FetchType.LAZY, orphanRemoval = true)
+    var goalMappings: MutableList<ChatCharacterGoalMapping> = mutableListOf()
+
+    // 태그 추가 헬퍼 메소드
+    fun addTag(tag: ChatCharacterTag) {
+        val mapping = ChatCharacterTagMapping(this, tag)
+        tagMappings.add(mapping)
+    }
+
+    // 가치관 추가 헬퍼 메소드
+    fun addValue(value: ChatCharacterValue) {
+        val mapping = ChatCharacterValueMapping(this, value)
+        valueMappings.add(mapping)
+    }
+
+    // 취미 추가 헬퍼 메소드
+    fun addHobby(hobby: ChatCharacterHobby) {
+        val mapping = ChatCharacterHobbyMapping(this, hobby)
+        hobbyMappings.add(mapping)
+    }
+
+    // 목표 추가 헬퍼 메소드
+    fun addGoal(goal: ChatCharacterGoal) {
+        val mapping = ChatCharacterGoalMapping(this, goal)
+        goalMappings.add(mapping)
+    }
+
+    // 기억 추가 헬퍼 메소드
+    fun addMemory(title: String, content: String, emotion: String) {
+        val memory = ChatCharacterMemory(title, content, emotion, this)
+        memories.add(memory)
+    }
+
+    // 성격 추가 헬퍼 메소드
+    fun addPersonality(trait: String, description: String) {
+        val personality = ChatCharacterPersonality(trait, description, this)
+        personalities.add(personality)
+    }
+
+    // 배경 추가 헬퍼 메소드
+    fun addBackground(topic: String, description: String) {
+        val background = ChatCharacterBackground(topic, description, this)
+        backgrounds.add(background)
+    }
+
+    // 관계 추가 헬퍼 메소드
+    fun addRelationship(
+        personName: String,
+        relationshipName: String,
+        description: String,
+        importance: Int,
+        relationshipType: String,
+        currentStatus: String
+    ) {
+        val relationship = ChatCharacterRelationship(
+            personName,
+            relationshipName,
+            description,
+            importance,
+            relationshipType,
+            currentStatus,
+            this
+        )
+        relationships.add(relationship)
+    }
+}
+
+enum class CharacterType {
+    Clone,
+    Character
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/ChatCharacterBackground.kt

@@ -0,0 +1,26 @@
+package kr.co.vividnext.sodalive.chat.character
+
+import kr.co.vividnext.sodalive.common.BaseEntity
+import javax.persistence.Column
+import javax.persistence.Entity
+import javax.persistence.FetchType
+import javax.persistence.JoinColumn
+import javax.persistence.ManyToOne
+
+/**
+ * 캐릭터 배경 정보
+ */
+
+@Entity
+class ChatCharacterBackground(
+    // 배경 주제
+    val topic: String,
+
+    // 배경 설명
+    @Column(columnDefinition = "TEXT", nullable = false)
+    var description: String,
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "chat_character_id")
+    val chatCharacter: ChatCharacter
+) : BaseEntity()

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/ChatCharacterBanner.kt

@@ -0,0 +1,29 @@
+package kr.co.vividnext.sodalive.chat.character
+
+import kr.co.vividnext.sodalive.common.BaseEntity
+import javax.persistence.Entity
+import javax.persistence.FetchType
+import javax.persistence.JoinColumn
+import javax.persistence.ManyToOne
+
+/**
+ * 캐릭터 배너 엔티티
+ * 이미지와 캐릭터 ID를 가지며, 소프트 삭제(isActive = false)를 지원합니다.
+ * 정렬 순서(sortOrder)를 통해 배너의 표시 순서를 결정합니다.
+ */
+@Entity
+class ChatCharacterBanner(
+    // 배너 이미지 경로
+    var imagePath: String? = null,
+
+    // 연관된 캐릭터
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "character_id")
+    var chatCharacter: ChatCharacter,
+
+    // 정렬 순서 (낮을수록 먼저 표시)
+    var sortOrder: Int = 0,
+
+    // 활성화 여부 (소프트 삭제용)
+    var isActive: Boolean = true
+) : BaseEntity()

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/ChatCharacterGoal.kt

@@ -0,0 +1,22 @@
+package kr.co.vividnext.sodalive.chat.character
+
+import kr.co.vividnext.sodalive.common.BaseEntity
+import javax.persistence.Column
+import javax.persistence.Entity
+import javax.persistence.OneToMany
+import javax.persistence.Table
+import javax.persistence.UniqueConstraint
+
+/**
+ * 캐릭터 목표
+ */
+
+@Entity
+@Table(uniqueConstraints = [UniqueConstraint(columnNames = ["goal"])])
+class ChatCharacterGoal(
+    @Column(nullable = false)
+    val goal: String
+) : BaseEntity() {
+    @OneToMany(mappedBy = "goal")
+    var goalMappings: MutableList<ChatCharacterGoalMapping> = mutableListOf()
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/ChatCharacterGoalMapping.kt

@@ -0,0 +1,22 @@
+package kr.co.vividnext.sodalive.chat.character
+
+import kr.co.vividnext.sodalive.common.BaseEntity
+import javax.persistence.Entity
+import javax.persistence.FetchType
+import javax.persistence.JoinColumn
+import javax.persistence.ManyToOne
+
+/**
+ * ChatCharacter와 ChatCharacterGoal 간의 매핑 엔티티
+ * ChatCharacterGoal의 중복을 방지하기 위한 매핑 테이블
+ */
+@Entity
+class ChatCharacterGoalMapping(
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "chat_character_id")
+    val chatCharacter: ChatCharacter,
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "goal_id")
+    val goal: ChatCharacterGoal
+) : BaseEntity()

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/ChatCharacterHobby.kt

@@ -0,0 +1,22 @@
+package kr.co.vividnext.sodalive.chat.character
+
+import kr.co.vividnext.sodalive.common.BaseEntity
+import javax.persistence.Column
+import javax.persistence.Entity
+import javax.persistence.OneToMany
+import javax.persistence.Table
+import javax.persistence.UniqueConstraint
+
+/**
+ * 캐릭터 취미
+ */
+
+@Entity
+@Table(uniqueConstraints = [UniqueConstraint(columnNames = ["hobby"])])
+class ChatCharacterHobby(
+    @Column(nullable = false)
+    val hobby: String
+) : BaseEntity() {
+    @OneToMany(mappedBy = "hobby")
+    var hobbyMappings: MutableList<ChatCharacterHobbyMapping> = mutableListOf()
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/ChatCharacterHobbyMapping.kt

@@ -0,0 +1,22 @@
+package kr.co.vividnext.sodalive.chat.character
+
+import kr.co.vividnext.sodalive.common.BaseEntity
+import javax.persistence.Entity
+import javax.persistence.FetchType
+import javax.persistence.JoinColumn
+import javax.persistence.ManyToOne
+
+/**
+ * ChatCharacter와 ChatCharacterHobby 간의 매핑 엔티티
+ * ChatCharacterHobby의 중복을 방지하기 위한 매핑 테이블
+ */
+@Entity
+class ChatCharacterHobbyMapping(
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "chat_character_id")
+    val chatCharacter: ChatCharacter,
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "hobby_id")
+    val hobby: ChatCharacterHobby
+) : BaseEntity()

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/ChatCharacterMemory.kt

@@ -0,0 +1,29 @@
+package kr.co.vividnext.sodalive.chat.character
+
+import kr.co.vividnext.sodalive.common.BaseEntity
+import javax.persistence.Column
+import javax.persistence.Entity
+import javax.persistence.FetchType
+import javax.persistence.JoinColumn
+import javax.persistence.ManyToOne
+
+/**
+ * 캐릭터 기억
+ */
+
+@Entity
+class ChatCharacterMemory(
+    // 기억 제목
+    val title: String,
+
+    // 기억 내용
+    @Column(columnDefinition = "TEXT", nullable = false)
+    var content: String,
+
+    // 감정
+    var emotion: String,
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "chat_character_id")
+    val chatCharacter: ChatCharacter
+) : BaseEntity()

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/ChatCharacterPersonality.kt

@@ -0,0 +1,26 @@
+package kr.co.vividnext.sodalive.chat.character
+
+import kr.co.vividnext.sodalive.common.BaseEntity
+import javax.persistence.Column
+import javax.persistence.Entity
+import javax.persistence.FetchType
+import javax.persistence.JoinColumn
+import javax.persistence.ManyToOne
+
+/**
+ * 캐릭터 성격 특성
+ */
+
+@Entity
+class ChatCharacterPersonality(
+    // 성격 특성
+    val trait: String,
+
+    // 성격 특성 설명
+    @Column(columnDefinition = "TEXT", nullable = false)
+    var description: String,
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "chat_character_id")
+    val chatCharacter: ChatCharacter
+) : BaseEntity()

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/ChatCharacterRelationship.kt

@@ -0,0 +1,33 @@
+package kr.co.vividnext.sodalive.chat.character
+
+import kr.co.vividnext.sodalive.common.BaseEntity
+import javax.persistence.Column
+import javax.persistence.Entity
+import javax.persistence.FetchType
+import javax.persistence.JoinColumn
+import javax.persistence.ManyToOne
+
+/**
+ * 캐릭터 관계
+ */
+
+@Entity
+class ChatCharacterRelationship(
+    // 상대 인물 이름
+    var personName: String,
+    // 관계명 (예: 친구, 동료 등)
+    var relationshipName: String,
+    // 관계 설명
+    @Column(columnDefinition = "TEXT")
+    var description: String,
+    // 중요도
+    var importance: Int,
+    // 관계 타입 (분류용)
+    var relationshipType: String,
+    // 현재 상태
+    var currentStatus: String,
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "chat_character_id")
+    val chatCharacter: ChatCharacter
+) : BaseEntity()

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/ChatCharacterTag.kt

@@ -0,0 +1,22 @@
+package kr.co.vividnext.sodalive.chat.character
+
+import kr.co.vividnext.sodalive.common.BaseEntity
+import javax.persistence.Column
+import javax.persistence.Entity
+import javax.persistence.OneToMany
+import javax.persistence.Table
+import javax.persistence.UniqueConstraint
+
+/**
+ * 캐릭터 태그
+ */
+
+@Entity
+@Table(uniqueConstraints = [UniqueConstraint(columnNames = ["tag"])])
+class ChatCharacterTag(
+    @Column(nullable = false)
+    val tag: String
+) : BaseEntity() {
+    @OneToMany(mappedBy = "tag")
+    var tagMappings: MutableList<ChatCharacterTagMapping> = mutableListOf()
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/ChatCharacterTagMapping.kt

@@ -0,0 +1,22 @@
+package kr.co.vividnext.sodalive.chat.character
+
+import kr.co.vividnext.sodalive.common.BaseEntity
+import javax.persistence.Entity
+import javax.persistence.FetchType
+import javax.persistence.JoinColumn
+import javax.persistence.ManyToOne
+
+/**
+ * ChatCharacter와 ChatCharacterTag 간의 매핑 엔티티
+ * ChatCharacterTag의 중복을 방지하기 위한 매핑 테이블
+ */
+@Entity
+class ChatCharacterTagMapping(
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "chat_character_id")
+    val chatCharacter: ChatCharacter,
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "tag_id")
+    val tag: ChatCharacterTag
+) : BaseEntity()

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/ChatCharacterValue.kt

@@ -0,0 +1,22 @@
+package kr.co.vividnext.sodalive.chat.character
+
+import kr.co.vividnext.sodalive.common.BaseEntity
+import javax.persistence.Column
+import javax.persistence.Entity
+import javax.persistence.OneToMany
+import javax.persistence.Table
+import javax.persistence.UniqueConstraint
+
+/**
+ * 캐릭터 가치관
+ */
+
+@Entity
+@Table(uniqueConstraints = [UniqueConstraint(columnNames = ["value"])])
+class ChatCharacterValue(
+    @Column(nullable = false)
+    val value: String
+) : BaseEntity() {
+    @OneToMany(mappedBy = "value")
+    var valueMappings: MutableList<ChatCharacterValueMapping> = mutableListOf()
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/ChatCharacterValueMapping.kt

@@ -0,0 +1,22 @@
+package kr.co.vividnext.sodalive.chat.character
+
+import kr.co.vividnext.sodalive.common.BaseEntity
+import javax.persistence.Entity
+import javax.persistence.FetchType
+import javax.persistence.JoinColumn
+import javax.persistence.ManyToOne
+
+/**
+ * ChatCharacter와 ChatCharacterValue 간의 매핑 엔티티
+ * ChatCharacterValue의 중복을 방지하기 위한 매핑 테이블
+ */
+@Entity
+class ChatCharacterValueMapping(
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "chat_character_id")
+    val chatCharacter: ChatCharacter,
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "value_id")
+    val value: ChatCharacterValue
+) : BaseEntity()

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/README.md

@@ -0,0 +1,118 @@
+# ChatCharacter 엔티티 관계 구현
+
+## 개요
+
+이 구현은 ChatCharacter와 다른 엔티티들 간의 1:N 관계를 설정합니다. ChatCharacter가 저장될 때 관련 엔티티들도 함께 저장되며, Tag, Value, Hobby, Goal은 중복을 허용하지 않고 기존 내용과 동일한 내용이 들어오면 관계만 맺습니다.
+
+## 엔티티 구조
+
+### 주요 엔티티
+
+- **ChatCharacter**: 메인 엔티티로, 캐릭터의 기본 정보를 저장합니다.
+- **ChatCharacterMemory**: 캐릭터의 기억 정보를 저장합니다.
+- **ChatCharacterPersonality**: 캐릭터의 성격 특성을 저장합니다.
+- **ChatCharacterBackground**: 캐릭터의 배경 정보를 저장합니다.
+- **ChatCharacterRelationship**: 캐릭터의 관계 정보를 저장합니다.
+
+### 중복 방지를 위한 엔티티
+
+- **ChatCharacterTag**: 캐릭터 태그 정보를 저장합니다. 태그 이름은 유일합니다.
+- **ChatCharacterValue**: 캐릭터 가치관 정보를 저장합니다. 가치관 이름은 유일합니다.
+- **ChatCharacterHobby**: 캐릭터 취미 정보를 저장합니다. 취미 이름은 유일합니다.
+- **ChatCharacterGoal**: 캐릭터 목표 정보를 저장합니다. 목표 이름은 유일합니다.
+
+### 매핑 엔티티
+
+- **ChatCharacterTagMapping**: ChatCharacter와 ChatCharacterTag 간의 관계를 맺습니다.
+- **ChatCharacterValueMapping**: ChatCharacter와 ChatCharacterValue 간의 관계를 맺습니다.
+- **ChatCharacterHobbyMapping**: ChatCharacter와 ChatCharacterHobby 간의 관계를 맺습니다.
+- **ChatCharacterGoalMapping**: ChatCharacter와 ChatCharacterGoal 간의 관계를 맺습니다.
+
+## 관계 설정
+
+- ChatCharacter와 Memory, Personality, Background, Relationship은 1:N 관계입니다.
+- ChatCharacter와 Tag, Value, Hobby, Goal은 매핑 엔티티를 통한 N:M 관계입니다.
+- 모든 관계는 ChatCharacter가 저장될 때 함께 저장됩니다(CascadeType.ALL).
+
+## 서비스 기능
+
+ChatCharacterService는 다음과 같은 기능을 제공합니다:
+
+1. 캐릭터 생성 및 저장
+2. 캐릭터 조회 (UUID, 이름, 전체 목록)
+3. 캐릭터에 태그, 가치관, 취미, 목표 추가
+4. 캐릭터에 기억, 성격 특성, 배경 정보, 관계 추가
+5. 모든 정보를 포함한 캐릭터 생성
+
+## 사용 예시
+
+```kotlin
+// 캐릭터 생성
+val chatCharacter = chatCharacterService.createChatCharacter(
+    characterUUID = "uuid-123",
+    name = "AI 어시스턴트",
+    description = "친절한 AI 어시스턴트",
+    systemPrompt = "당신은 친절한 AI 어시스턴트입니다."
+)
+
+// 태그 추가
+chatCharacterService.addTagToCharacter(chatCharacter, "친절함")
+chatCharacterService.addTagToCharacter(chatCharacter, "도움")
+
+// 가치관 추가
+chatCharacterService.addValueToCharacter(chatCharacter, "정직")
+
+// 취미 추가
+chatCharacterService.addHobbyToCharacter(chatCharacter, "독서")
+
+// 목표 추가
+chatCharacterService.addGoalToCharacter(chatCharacter, "사용자 만족")
+
+// 기억 추가
+chatCharacterService.addMemoryToChatCharacter(
+    chatCharacter,
+    "첫 만남",
+    "사용자와의 첫 대화",
+    "기쁨"
+)
+
+// 성격 특성 추가
+chatCharacterService.addPersonalityToChatCharacter(
+    chatCharacter,
+    "친절함",
+    "항상 친절하게 대응합니다."
+)
+
+// 배경 정보 추가
+chatCharacterService.addBackgroundToChatCharacter(
+    chatCharacter,
+    "생성 배경",
+    "사용자를 돕기 위해 만들어졌습니다."
+)
+
+// 관계 추가
+chatCharacterService.addRelationshipToChatCharacter(
+    chatCharacter,
+    "사용자와의 관계: 도우미"
+)
+
+// 모든 정보를 포함한 캐릭터 생성
+val completeCharacter = chatCharacterService.createChatCharacterWithDetails(
+    characterUUID = "uuid-456",
+    name = "종합 AI",
+    description = "모든 정보를 가진 AI",
+    systemPrompt = "당신은 모든 정보를 가진 AI입니다.",
+    tags = listOf("종합", "지식"),
+    values = listOf("정확성", "유용성"),
+    hobbies = listOf("학습", "정보 수집"),
+    goals = listOf("정확한 정보 제공"),
+    memories = listOf(Triple("학습 시작", "처음 학습을 시작했습니다.", "호기심")),
+    personalities = listOf(Pair("분석적", "정보를 분석적으로 처리합니다.")),
+    backgrounds = listOf(Pair("개발 목적", "정보 제공을 위해 개발되었습니다.")),
+    relationships = listOf("사용자와의 관계: 정보 제공자")
+)
+```
+
+## 중복 방지 메커니즘
+
+Tag, Value, Hobby, Goal 엔티티는 각각 고유한 필드(tag, value, hobby, goal)에 대해 유니크 제약 조건을 가지고 있습니다. 서비스 레이어에서는 이미 존재하는 엔티티를 찾아 재사용하거나, 존재하지 않는 경우 새로 생성합니다. 이를 통해 중복을 방지하고 관계만 맺을 수 있습니다.

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/comment/CharacterComment.kt

@@ -0,0 +1,39 @@
+package kr.co.vividnext.sodalive.chat.character.comment
+
+import kr.co.vividnext.sodalive.chat.character.ChatCharacter
+import kr.co.vividnext.sodalive.common.BaseEntity
+import kr.co.vividnext.sodalive.member.Member
+import javax.persistence.Column
+import javax.persistence.Entity
+import javax.persistence.FetchType
+import javax.persistence.JoinColumn
+import javax.persistence.ManyToOne
+import javax.persistence.OneToMany
+import javax.persistence.Table
+
+@Entity
+@Table(name = "character_comment")
+data class CharacterComment(
+    @Column(columnDefinition = "TEXT", nullable = false)
+    var comment: String,
+    var isActive: Boolean = true
+) : BaseEntity() {
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "parent_id", nullable = true)
+    var parent: CharacterComment? = null
+        set(value) {
+            value?.children?.add(this)
+            field = value
+        }
+
+    @OneToMany(mappedBy = "parent")
+    var children: MutableList<CharacterComment> = mutableListOf()
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "member_id", nullable = false)
+    var member: Member? = null
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "character_id", nullable = false)
+    var chatCharacter: ChatCharacter? = null
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/comment/CharacterCommentController.kt

@@ -0,0 +1,108 @@
+package kr.co.vividnext.sodalive.chat.character.comment
+
+import kr.co.vividnext.sodalive.common.ApiResponse
+import kr.co.vividnext.sodalive.common.SodaException
+import kr.co.vividnext.sodalive.member.Member
+import org.springframework.beans.factory.annotation.Value
+import org.springframework.security.core.annotation.AuthenticationPrincipal
+import org.springframework.web.bind.annotation.DeleteMapping
+import org.springframework.web.bind.annotation.GetMapping
+import org.springframework.web.bind.annotation.PathVariable
+import org.springframework.web.bind.annotation.PostMapping
+import org.springframework.web.bind.annotation.RequestBody
+import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RequestParam
+import org.springframework.web.bind.annotation.RestController
+
+@RestController
+@RequestMapping("/api/chat/character")
+class CharacterCommentController(
+    private val service: CharacterCommentService,
+    @Value("\${cloud.aws.cloud-front.host}")
+    private val imageHost: String
+) {
+
+    @PostMapping("/{characterId}/comments")
+    fun createComment(
+        @PathVariable characterId: Long,
+        @RequestBody request: CreateCharacterCommentRequest,
+        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?
+    ) = run {
+        if (member == null) throw SodaException("로그인 정보를 확인해주세요.")
+        if (member.auth == null) throw SodaException("본인인증을 하셔야 합니다.")
+        if (request.comment.isBlank()) throw SodaException("댓글 내용을 입력해주세요.")
+
+        val id = service.addComment(characterId, member, request.comment)
+        ApiResponse.ok(id)
+    }
+
+    @PostMapping("/{characterId}/comments/{commentId}/replies")
+    fun createReply(
+        @PathVariable characterId: Long,
+        @PathVariable commentId: Long,
+        @RequestBody request: CreateCharacterCommentRequest,
+        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?
+    ) = run {
+        if (member == null) throw SodaException("로그인 정보를 확인해주세요.")
+        if (member.auth == null) throw SodaException("본인인증을 하셔야 합니다.")
+        if (request.comment.isBlank()) throw SodaException("댓글 내용을 입력해주세요.")
+
+        val id = service.addReply(characterId, commentId, member, request.comment)
+        ApiResponse.ok(id)
+    }
+
+    @GetMapping("/{characterId}/comments")
+    fun listComments(
+        @PathVariable characterId: Long,
+        @RequestParam(required = false, defaultValue = "20") limit: Int,
+        @RequestParam(required = false) cursor: Long?,
+        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?
+    ) = run {
+        if (member == null) throw SodaException("로그인 정보를 확인해주세요.")
+        if (member.auth == null) throw SodaException("본인인증을 하셔야 합니다.")
+
+        val data = service.listComments(imageHost, characterId, cursor, limit)
+        ApiResponse.ok(data)
+    }
+
+    @GetMapping("/{characterId}/comments/{commentId}/replies")
+    fun listReplies(
+        @PathVariable characterId: Long,
+        @PathVariable commentId: Long,
+        @RequestParam(required = false, defaultValue = "20") limit: Int,
+        @RequestParam(required = false) cursor: Long?,
+        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?
+    ) = run {
+        if (member == null) throw SodaException("로그인 정보를 확인해주세요.")
+        if (member.auth == null) throw SodaException("본인인증을 하셔야 합니다.")
+
+        // characterId는 서비스 내부 검증(원본 댓글과 캐릭터 일치)에서 검증됨
+        val data = service.getReplies(imageHost, commentId, cursor, limit)
+        ApiResponse.ok(data)
+    }
+
+    @DeleteMapping("/{characterId}/comments/{commentId}")
+    fun deleteComment(
+        @PathVariable characterId: Long,
+        @PathVariable commentId: Long,
+        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?
+    ) = run {
+        if (member == null) throw SodaException("로그인 정보를 확인해주세요.")
+        if (member.auth == null) throw SodaException("본인인증을 하셔야 합니다.")
+        service.deleteComment(characterId, commentId, member)
+        ApiResponse.ok(true, "댓글이 삭제되었습니다.")
+    }
+
+    @PostMapping("/{characterId}/comments/{commentId}/reports")
+    fun reportComment(
+        @PathVariable characterId: Long,
+        @PathVariable commentId: Long,
+        @RequestBody request: ReportCharacterCommentRequest,
+        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?
+    ) = run {
+        if (member == null) throw SodaException("로그인 정보를 확인해주세요.")
+        if (member.auth == null) throw SodaException("본인인증을 하셔야 합니다.")
+        service.reportComment(characterId, commentId, member, request.content)
+        ApiResponse.ok(true, "신고가 접수되었습니다.")
+    }
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/comment/CharacterCommentDto.kt

@@ -0,0 +1,64 @@
+package kr.co.vividnext.sodalive.chat.character.comment
+
+// Request DTOs
+data class CreateCharacterCommentRequest(
+    val comment: String
+)
+
+// Response DTOs
+// 댓글 Response
+// - 댓글 ID
+// - 댓글 쓴 Member 프로필 이미지
+// - 댓글 쓴 Member 닉네임
+// - 댓글 쓴 시간 timestamp(long)
+// - 답글 수
+
+data class CharacterCommentResponse(
+    val commentId: Long,
+    val memberId: Long,
+    val memberProfileImage: String,
+    val memberNickname: String,
+    val createdAt: Long,
+    val replyCount: Int,
+    val comment: String
+)
+
+// 답글 Response 단건(목록 원소)
+// - 답글 ID
+// - 답글 쓴 Member 프로필 이미지
+// - 답글 쓴 Member 닉네임
+// - 답글 쓴 시간 timestamp(long)
+
+data class CharacterReplyResponse(
+    val replyId: Long,
+    val memberId: Long,
+    val memberProfileImage: String,
+    val memberNickname: String,
+    val createdAt: Long,
+    val comment: String
+)
+
+// 댓글의 답글 조회 Response 컨테이너
+// - 원본 댓글 Response
+// - 답글 목록(위 사양의 필드 포함)
+
+data class CharacterCommentRepliesResponse(
+    val original: CharacterCommentResponse,
+    val replies: List<CharacterReplyResponse>,
+    val cursor: Long?
+)
+
+// 댓글 리스트 조회 Response 컨테이너
+// - 전체 댓글 개수(totalCount)
+// - 댓글 목록(comments)
+
+data class CharacterCommentListResponse(
+    val totalCount: Int,
+    val comments: List<CharacterCommentResponse>,
+    val cursor: Long?
+)
+
+// 신고 Request
+data class ReportCharacterCommentRequest(
+    val content: String
+)

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/comment/CharacterCommentReport.kt

@@ -0,0 +1,25 @@
+package kr.co.vividnext.sodalive.chat.character.comment
+
+import kr.co.vividnext.sodalive.common.BaseEntity
+import kr.co.vividnext.sodalive.member.Member
+import javax.persistence.Column
+import javax.persistence.Entity
+import javax.persistence.FetchType
+import javax.persistence.JoinColumn
+import javax.persistence.ManyToOne
+import javax.persistence.Table
+
+@Entity
+@Table(name = "character_comment_report")
+data class CharacterCommentReport(
+    @Column(columnDefinition = "TEXT", nullable = false)
+    val content: String
+) : BaseEntity() {
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "comment_id", nullable = false)
+    var comment: CharacterComment? = null
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "member_id", nullable = false)
+    var member: Member? = null
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/comment/CharacterCommentReportRepository.kt

@@ -0,0 +1,5 @@
+package kr.co.vividnext.sodalive.chat.character.comment
+
+import org.springframework.data.jpa.repository.JpaRepository
+
+interface CharacterCommentReportRepository : JpaRepository<CharacterCommentReport, Long>

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/comment/CharacterCommentRepository.kt

@@ -0,0 +1,38 @@
+package kr.co.vividnext.sodalive.chat.character.comment
+
+import org.springframework.data.domain.Pageable
+import org.springframework.data.jpa.repository.JpaRepository
+
+interface CharacterCommentRepository : JpaRepository<CharacterComment, Long> {
+    fun findByChatCharacter_IdAndIsActiveTrueAndParentIsNullOrderByCreatedAtDesc(
+        chatCharacterId: Long,
+        pageable: Pageable
+    ): List<CharacterComment>
+
+    fun findByChatCharacter_IdAndIsActiveTrueAndParentIsNullAndIdLessThanOrderByCreatedAtDesc(
+        chatCharacterId: Long,
+        id: Long,
+        pageable: Pageable
+    ): List<CharacterComment>
+
+    fun countByParent_IdAndIsActiveTrue(parentId: Long): Int
+
+    fun findByParent_IdAndIsActiveTrueOrderByCreatedAtDesc(parentId: Long, pageable: Pageable): List<CharacterComment>
+
+    fun findByParent_IdAndIsActiveTrueAndIdLessThanOrderByCreatedAtDesc(
+        parentId: Long,
+        id: Long,
+        pageable: Pageable
+    ): List<CharacterComment>
+
+    // 최신 원댓글만 조회
+    fun findFirstByChatCharacter_IdAndIsActiveTrueAndParentIsNullOrderByCreatedAtDesc(
+        chatCharacterId: Long
+    ): CharacterComment?
+
+    // 활성 원댓글 수
+    fun countByChatCharacter_IdAndIsActiveTrueAndParentIsNull(chatCharacterId: Long): Int
+
+    // 활성 부모를 가진 활성 답글 수 (부모가 null인 경우 제외됨)
+    fun countByChatCharacter_IdAndIsActiveTrueAndParent_IsActiveTrue(chatCharacterId: Long): Int
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/comment/CharacterCommentService.kt

@@ -0,0 +1,194 @@
+package kr.co.vividnext.sodalive.chat.character.comment
+
+import kr.co.vividnext.sodalive.chat.character.repository.ChatCharacterRepository
+import kr.co.vividnext.sodalive.common.SodaException
+import kr.co.vividnext.sodalive.member.Member
+import org.springframework.data.domain.PageRequest
+import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
+import java.time.ZoneId
+
+@Service
+class CharacterCommentService(
+    private val chatCharacterRepository: ChatCharacterRepository,
+    private val commentRepository: CharacterCommentRepository,
+    private val reportRepository: CharacterCommentReportRepository
+) {
+
+    private fun profileUrl(imageHost: String, profileImage: String?): String {
+        return if (profileImage.isNullOrBlank()) {
+            "$imageHost/profile/default-profile.png"
+        } else {
+            "$imageHost/$profileImage"
+        }
+    }
+
+    private fun toEpochMilli(created: java.time.LocalDateTime?): Long {
+        return created?.atZone(ZoneId.systemDefault())?.toInstant()?.toEpochMilli() ?: 0L
+    }
+
+    private fun toCommentResponse(
+        imageHost: String,
+        entity: CharacterComment,
+        replyCountOverride: Int? = null
+    ): CharacterCommentResponse {
+        val member = entity.member ?: throw SodaException("유효하지 않은 댓글입니다.")
+        return CharacterCommentResponse(
+            commentId = entity.id!!,
+            memberId = member.id!!,
+            memberProfileImage = profileUrl(imageHost, member.profileImage),
+            memberNickname = member.nickname,
+            createdAt = toEpochMilli(entity.createdAt),
+            replyCount = replyCountOverride ?: commentRepository.countByParent_IdAndIsActiveTrue(entity.id!!),
+            comment = entity.comment
+        )
+    }
+
+    private fun toReplyResponse(imageHost: String, entity: CharacterComment): CharacterReplyResponse {
+        val member = entity.member ?: throw SodaException("유효하지 않은 댓글입니다.")
+        return CharacterReplyResponse(
+            replyId = entity.id!!,
+            memberId = member.id!!,
+            memberProfileImage = profileUrl(imageHost, member.profileImage),
+            memberNickname = member.nickname,
+            createdAt = toEpochMilli(entity.createdAt),
+            comment = entity.comment
+        )
+    }
+
+    @Transactional
+    fun addComment(characterId: Long, member: Member, text: String): Long {
+        val character = chatCharacterRepository.findById(characterId).orElseThrow { SodaException("캐릭터를 찾을 수 없습니다.") }
+        if (!character.isActive) throw SodaException("비활성화된 캐릭터입니다.")
+        if (text.isBlank()) throw SodaException("댓글 내용을 입력해주세요.")
+
+        val entity = CharacterComment(comment = text)
+        entity.chatCharacter = character
+        entity.member = member
+        commentRepository.save(entity)
+        return entity.id!!
+    }
+
+    @Transactional
+    fun addReply(characterId: Long, parentCommentId: Long, member: Member, text: String): Long {
+        val character = chatCharacterRepository.findById(characterId).orElseThrow { SodaException("캐릭터를 찾을 수 없습니다.") }
+        if (!character.isActive) throw SodaException("비활성화된 캐릭터입니다.")
+        val parent = commentRepository.findById(parentCommentId).orElseThrow { SodaException("댓글을 찾을 수 없습니다.") }
+        if (parent.chatCharacter?.id != characterId) throw SodaException("잘못된 요청입니다.")
+        if (!parent.isActive) throw SodaException("비활성화된 댓글입니다.")
+        if (text.isBlank()) throw SodaException("댓글 내용을 입력해주세요.")
+
+        val entity = CharacterComment(comment = text)
+        entity.chatCharacter = character
+        entity.member = member
+        entity.parent = parent
+        commentRepository.save(entity)
+        return entity.id!!
+    }
+
+    @Transactional(readOnly = true)
+    fun listComments(
+        imageHost: String,
+        characterId: Long,
+        cursor: Long?,
+        limit: Int = 20
+    ): CharacterCommentListResponse {
+        val pageable = PageRequest.of(0, limit)
+        val comments = if (cursor == null) {
+            commentRepository.findByChatCharacter_IdAndIsActiveTrueAndParentIsNullOrderByCreatedAtDesc(
+                characterId,
+                pageable
+            )
+        } else {
+            commentRepository.findByChatCharacter_IdAndIsActiveTrueAndParentIsNullAndIdLessThanOrderByCreatedAtDesc(
+                characterId,
+                cursor,
+                pageable
+            )
+        }
+
+        val items = comments.map { toCommentResponse(imageHost, it) }
+        val total = getTotalCommentCount(characterId)
+        val nextCursor = if (items.size == limit) items.lastOrNull()?.commentId else null
+
+        return CharacterCommentListResponse(
+            totalCount = total,
+            comments = items,
+            cursor = nextCursor
+        )
+    }
+
+    @Transactional(readOnly = true)
+    fun getReplies(
+        imageHost: String,
+        commentId: Long,
+        cursor: Long?,
+        limit: Int = 20
+    ): CharacterCommentRepliesResponse {
+        val original = commentRepository.findById(commentId).orElseThrow {
+            SodaException("댓글을 찾을 수 없습니다.")
+        }
+        if (!original.isActive) throw SodaException("비활성화된 댓글입니다.")
+
+        val pageable = PageRequest.of(0, limit)
+        val replies = if (cursor == null) {
+            commentRepository.findByParent_IdAndIsActiveTrueOrderByCreatedAtDesc(commentId, pageable)
+        } else {
+            commentRepository.findByParent_IdAndIsActiveTrueAndIdLessThanOrderByCreatedAtDesc(
+                commentId,
+                cursor,
+                pageable
+            )
+        }
+
+        val items = replies.map { toReplyResponse(imageHost, it) }
+        val nextCursor = if (items.size == limit) items.lastOrNull()?.replyId else null
+
+        return CharacterCommentRepliesResponse(
+            original = toCommentResponse(imageHost, original, 0),
+            replies = items,
+            cursor = nextCursor
+        )
+    }
+
+    @Transactional(readOnly = true)
+    fun getLatestComment(imageHost: String, characterId: Long): CharacterCommentResponse? {
+        return commentRepository
+            .findFirstByChatCharacter_IdAndIsActiveTrueAndParentIsNullOrderByCreatedAtDesc(characterId)
+            ?.let { toCommentResponse(imageHost, it) }
+    }
+
+    @Transactional(readOnly = true)
+    fun getTotalCommentCount(characterId: Long): Int {
+        // 활성 원댓글 수 + 활성 부모를 가진 활성 답글 수
+        val originalCount = commentRepository
+            .countByChatCharacter_IdAndIsActiveTrueAndParentIsNull(characterId)
+        val replyWithActiveParentCount = commentRepository
+            .countByChatCharacter_IdAndIsActiveTrueAndParent_IsActiveTrue(characterId)
+
+        return originalCount + replyWithActiveParentCount
+    }
+
+    @Transactional
+    fun deleteComment(characterId: Long, commentId: Long, member: Member) {
+        val comment = commentRepository.findById(commentId).orElseThrow { SodaException("댓글을 찾을 수 없습니다.") }
+        if (comment.chatCharacter?.id != characterId) throw SodaException("잘못된 요청입니다.")
+        if (!comment.isActive) return
+        val ownerId = comment.member?.id ?: throw SodaException("유효하지 않은 댓글입니다.")
+        if (ownerId != member.id) throw SodaException("삭제 권한이 없습니다.")
+        comment.isActive = false
+        commentRepository.save(comment)
+    }
+
+    @Transactional
+    fun reportComment(characterId: Long, commentId: Long, member: Member, content: String) {
+        val comment = commentRepository.findById(commentId).orElseThrow { SodaException("댓글을 찾을 수 없습니다.") }
+        if (comment.chatCharacter?.id != characterId) throw SodaException("잘못된 요청입니다.")
+        if (content.isBlank()) throw SodaException("신고 내용을 입력해주세요.")
+
+        val report = CharacterCommentReport(content = content)
+        report.comment = comment
+        report.member = member
+        reportRepository.save(report)
+    }
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/controller/ChatCharacterController.kt

@@ -0,0 +1,193 @@
+package kr.co.vividnext.sodalive.chat.character.controller
+
+import kr.co.vividnext.sodalive.chat.character.comment.CharacterCommentService
+import kr.co.vividnext.sodalive.chat.character.dto.Character
+import kr.co.vividnext.sodalive.chat.character.dto.CharacterBackgroundResponse
+import kr.co.vividnext.sodalive.chat.character.dto.CharacterBannerResponse
+import kr.co.vividnext.sodalive.chat.character.dto.CharacterDetailResponse
+import kr.co.vividnext.sodalive.chat.character.dto.CharacterMainResponse
+import kr.co.vividnext.sodalive.chat.character.dto.CharacterPersonalityResponse
+import kr.co.vividnext.sodalive.chat.character.dto.CurationSection
+import kr.co.vividnext.sodalive.chat.character.dto.OtherCharacter
+import kr.co.vividnext.sodalive.chat.character.dto.RecentCharacter
+import kr.co.vividnext.sodalive.chat.character.service.ChatCharacterBannerService
+import kr.co.vividnext.sodalive.chat.character.service.ChatCharacterService
+import kr.co.vividnext.sodalive.chat.room.service.ChatRoomService
+import kr.co.vividnext.sodalive.common.ApiResponse
+import kr.co.vividnext.sodalive.common.SodaException
+import kr.co.vividnext.sodalive.member.Member
+import org.springframework.beans.factory.annotation.Value
+import org.springframework.data.domain.PageRequest
+import org.springframework.security.core.annotation.AuthenticationPrincipal
+import org.springframework.web.bind.annotation.GetMapping
+import org.springframework.web.bind.annotation.PathVariable
+import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RestController
+
+@RestController
+@RequestMapping("/api/chat/character")
+class ChatCharacterController(
+    private val service: ChatCharacterService,
+    private val bannerService: ChatCharacterBannerService,
+    private val chatRoomService: ChatRoomService,
+    private val characterCommentService: CharacterCommentService,
+    private val curationQueryService: kr.co.vividnext.sodalive.chat.character.curation.CharacterCurationQueryService,
+
+    @Value("\${cloud.aws.cloud-front.host}")
+    private val imageHost: String
+) {
+    @GetMapping("/main")
+    fun getCharacterMain(
+        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?
+    ): ApiResponse<CharacterMainResponse> = run {
+        // 배너 조회 (최대 10개)
+        val banners = bannerService.getActiveBanners(PageRequest.of(0, 10))
+            .content
+            .map {
+                CharacterBannerResponse(
+                    characterId = it.chatCharacter.id!!,
+                    imageUrl = "$imageHost/${it.imagePath ?: "profile/default-profile.png"}"
+                )
+            }
+
+        // 최근 대화한 캐릭터(채팅방) 조회 (회원별 최근 순으로 최대 10개)
+        val recentCharacters = if (member == null || member.auth == null) {
+            emptyList()
+        } else {
+            chatRoomService.listMyChatRooms(member, 0, 10)
+                .map { room ->
+                    RecentCharacter(
+                        characterId = room.characterId,
+                        name = room.title,
+                        imageUrl = room.imageUrl
+                    )
+                }
+        }
+
+        // 인기 캐릭터 조회 (현재는 빈 리스트)
+        val popularCharacters = service.getPopularCharacters()
+            .map {
+                Character(
+                    characterId = it.id!!,
+                    name = it.name,
+                    description = it.description,
+                    imageUrl = "$imageHost/${it.imagePath ?: "profile/default-profile.png"}"
+                )
+            }
+
+        // 최신 캐릭터 조회 (최대 10개)
+        val newCharacters = service.getNewCharacters(50)
+            .map {
+                Character(
+                    characterId = it.id!!,
+                    name = it.name,
+                    description = it.description,
+                    imageUrl = "$imageHost/${it.imagePath ?: "profile/default-profile.png"}"
+                )
+            }
+
+        // 큐레이션 섹션 (활성화된 큐레이션 + 캐릭터)
+        val curationSections = curationQueryService.getActiveCurationsWithCharacters()
+            .map { agg ->
+                CurationSection(
+                    characterCurationId = agg.curation.id!!,
+                    title = agg.curation.title,
+                    characters = agg.characters.map {
+                        Character(
+                            characterId = it.id!!,
+                            name = it.name,
+                            description = it.description,
+                            imageUrl = "$imageHost/${it.imagePath ?: "profile/default-profile.png"}"
+                        )
+                    }
+                )
+            }
+
+        // 응답 생성
+        ApiResponse.ok(
+            CharacterMainResponse(
+                banners = banners,
+                recentCharacters = recentCharacters,
+                popularCharacters = popularCharacters,
+                newCharacters = newCharacters,
+                curationSections = curationSections
+            )
+        )
+    }
+
+    /**
+     * 캐릭터 상세 정보 조회 API
+     * 캐릭터 ID를 받아 해당 캐릭터의 상세 정보를 반환합니다.
+     */
+    @GetMapping("/{characterId}")
+    fun getCharacterDetail(
+        @PathVariable characterId: Long,
+        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?
+    ) = run {
+        if (member == null) throw SodaException("로그인 정보를 확인해주세요.")
+        if (member.auth == null) throw SodaException("본인인증을 하셔야 합니다.")
+
+        // 캐릭터 상세 정보 조회
+        val character = service.getCharacterDetail(characterId)
+            ?: throw SodaException("캐릭터를 찾을 수 없습니다.")
+
+        // 태그 가공: # prefix 규칙 적용 후 공백으로 연결
+        val tags = character.tagMappings
+            .map { it.tag.tag }
+            .joinToString(" ") { if (it.startsWith("#")) it else "#$it" }
+
+        // 성격, 배경: 각각 첫 번째 항목만 선택
+        val personality: CharacterPersonalityResponse? = character.personalities.firstOrNull()?.let {
+            CharacterPersonalityResponse(
+                trait = it.trait,
+                description = it.description
+            )
+        }
+
+        val background: CharacterBackgroundResponse? = character.backgrounds.firstOrNull()?.let {
+            CharacterBackgroundResponse(
+                topic = it.topic,
+                description = it.description
+            )
+        }
+
+        // 다른 캐릭터 조회 (태그 기반, 랜덤 10개, 현재 캐릭터 제외)
+        val others = service.getOtherCharactersBySharedTags(characterId, 10)
+            .map { other ->
+                val otherTags = other.tagMappings
+                    .map { it.tag.tag }
+                    .joinToString(" ") { if (it.startsWith("#")) it else "#$it" }
+                OtherCharacter(
+                    characterId = other.id!!,
+                    name = other.name,
+                    imageUrl = "$imageHost/${other.imagePath ?: "profile/default-profile.png"}",
+                    tags = otherTags
+                )
+            }
+
+        // 최신 댓글 1개 조회
+        val latestComment = characterCommentService.getLatestComment(imageHost, character.id!!)
+
+        // 응답 생성
+        ApiResponse.ok(
+            CharacterDetailResponse(
+                characterId = character.id!!,
+                name = character.name,
+                description = character.description,
+                mbti = character.mbti,
+                gender = character.gender,
+                age = character.age,
+                imageUrl = "$imageHost/${character.imagePath ?: "profile/default-profile.png"}",
+                personalities = personality,
+                backgrounds = background,
+                tags = tags,
+                originalTitle = character.originalTitle,
+                originalLink = character.originalLink,
+                characterType = character.characterType,
+                others = others,
+                latestComment = latestComment,
+                totalComments = characterCommentService.getTotalCommentCount(character.id!!)
+            )
+        )
+    }
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/curation/CharacterCuration.kt

@@ -0,0 +1,47 @@
+package kr.co.vividnext.sodalive.chat.character.curation
+
+import kr.co.vividnext.sodalive.chat.character.ChatCharacter
+import kr.co.vividnext.sodalive.common.BaseEntity
+import javax.persistence.CascadeType
+import javax.persistence.Column
+import javax.persistence.Entity
+import javax.persistence.FetchType
+import javax.persistence.JoinColumn
+import javax.persistence.ManyToOne
+import javax.persistence.OneToMany
+
+@Entity
+class CharacterCuration(
+    @Column(nullable = false)
+    var title: String,
+
+    // 19금 여부
+    @Column(nullable = false)
+    var isAdult: Boolean = false,
+
+    // 활성화 여부 (소프트 삭제)
+    @Column(nullable = false)
+    var isActive: Boolean = true,
+
+    // 정렬 순서 (낮을수록 먼저)
+    @Column(nullable = false)
+    var sortOrder: Int = 0
+) : BaseEntity() {
+    @OneToMany(mappedBy = "curation", cascade = [CascadeType.ALL], fetch = FetchType.LAZY, orphanRemoval = true)
+    var characterMappings: MutableList<CharacterCurationMapping> = mutableListOf()
+}
+
+@Entity
+class CharacterCurationMapping(
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "curation_id")
+    var curation: CharacterCuration,
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "character_id")
+    var chatCharacter: ChatCharacter,
+
+    // 정렬 순서 (낮을수록 먼저)
+    @Column(nullable = false)
+    var sortOrder: Int = 0
+) : BaseEntity()

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/curation/CharacterCurationQueryService.kt

@@ -0,0 +1,37 @@
+package kr.co.vividnext.sodalive.chat.character.curation
+
+import kr.co.vividnext.sodalive.chat.character.ChatCharacter
+import kr.co.vividnext.sodalive.chat.character.curation.repository.CharacterCurationMappingRepository
+import kr.co.vividnext.sodalive.chat.character.curation.repository.CharacterCurationRepository
+import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
+
+@Service
+class CharacterCurationQueryService(
+    private val curationRepository: CharacterCurationRepository,
+    private val mappingRepository: CharacterCurationMappingRepository
+) {
+    data class CurationAgg(
+        val curation: CharacterCuration,
+        val characters: List<ChatCharacter>
+    )
+
+    @Transactional(readOnly = true)
+    fun getActiveCurationsWithCharacters(): List<CurationAgg> {
+        val curations = curationRepository.findByIsActiveTrueOrderBySortOrderAsc()
+        if (curations.isEmpty()) return emptyList()
+
+        // 매핑 + 캐릭터를 한 번에 조회(ch.isActive = true 필터 적용)하여 N+1 해소
+        val mappings = mappingRepository
+            .findByCurationInWithActiveCharacterOrderByCurationIdAscAndSortOrderAsc(curations)
+
+        val charactersByCurationId: Map<Long, List<ChatCharacter>> = mappings
+            .groupBy { it.curation.id!! }
+            .mapValues { (_, list) -> list.map { it.chatCharacter } }
+
+        return curations.map { curation ->
+            val characters = charactersByCurationId[curation.id!!] ?: emptyList()
+            CurationAgg(curation, characters)
+        }
+    }
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/curation/repository/CharacterCurationMappingRepository.kt

@@ -0,0 +1,48 @@
+package kr.co.vividnext.sodalive.chat.character.curation.repository
+
+import kr.co.vividnext.sodalive.chat.character.curation.CharacterCuration
+import kr.co.vividnext.sodalive.chat.character.curation.CharacterCurationMapping
+import org.springframework.data.jpa.repository.JpaRepository
+import org.springframework.data.jpa.repository.Query
+import org.springframework.data.repository.query.Param
+import org.springframework.stereotype.Repository
+
+@Repository
+interface CharacterCurationMappingRepository : JpaRepository<CharacterCurationMapping, Long> {
+    fun findByCuration(curation: CharacterCuration): List<CharacterCurationMapping>
+
+    @Query(
+        "select m from CharacterCurationMapping m " +
+            "join fetch m.chatCharacter ch " +
+            "where m.curation in :curations and ch.isActive = true " +
+            "order by m.curation.id asc, m.sortOrder asc"
+    )
+    fun findByCurationInWithActiveCharacterOrderByCurationIdAscAndSortOrderAsc(
+        @Param("curations") curations: List<CharacterCuration>
+    ): List<CharacterCurationMapping>
+
+    @Query(
+        "select m from CharacterCurationMapping m " +
+            "join fetch m.chatCharacter ch " +
+            "where m.curation = :curation " +
+            "order by m.sortOrder asc"
+    )
+    fun findByCurationWithCharacterOrderBySortOrderAsc(
+        @Param("curation") curation: CharacterCuration
+    ): List<CharacterCurationMapping>
+
+    interface CharacterCountPerCuration {
+        val curationId: Long
+        val count: Long
+    }
+
+    @Query(
+        "select m.curation.id as curationId, count(m.id) as count " +
+            "from CharacterCurationMapping m join m.chatCharacter ch " +
+            "where m.curation in :curations and ch.isActive = true " +
+            "group by m.curation.id"
+    )
+    fun countActiveCharactersByCurations(
+        @Param("curations") curations: List<CharacterCuration>
+    ): List<CharacterCountPerCuration>
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/curation/repository/CharacterCurationRepository.kt

@@ -0,0 +1,14 @@
+package kr.co.vividnext.sodalive.chat.character.curation.repository
+
+import kr.co.vividnext.sodalive.chat.character.curation.CharacterCuration
+import org.springframework.data.jpa.repository.JpaRepository
+import org.springframework.data.jpa.repository.Query
+import org.springframework.stereotype.Repository
+
+@Repository
+interface CharacterCurationRepository : JpaRepository<CharacterCuration, Long> {
+    fun findByIsActiveTrueOrderBySortOrderAsc(): List<CharacterCuration>
+
+    @Query("SELECT MAX(c.sortOrder) FROM CharacterCuration c WHERE c.isActive = true")
+    fun findMaxSortOrder(): Int?
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/dto/CharacterDetailResponse.kt

@@ -0,0 +1,40 @@
+package kr.co.vividnext.sodalive.chat.character.dto
+
+import kr.co.vividnext.sodalive.chat.character.CharacterType
+import kr.co.vividnext.sodalive.chat.character.comment.CharacterCommentResponse
+
+data class CharacterDetailResponse(
+    val characterId: Long,
+    val name: String,
+    val description: String,
+    val mbti: String?,
+    val gender: String?,
+    val age: Int?,
+    val imageUrl: String,
+    val personalities: CharacterPersonalityResponse?,
+    val backgrounds: CharacterBackgroundResponse?,
+    val tags: String,
+    val originalTitle: String?,
+    val originalLink: String?,
+    val characterType: CharacterType,
+    val others: List<OtherCharacter>,
+    val latestComment: CharacterCommentResponse?,
+    val totalComments: Int
+)
+
+data class OtherCharacter(
+    val characterId: Long,
+    val name: String,
+    val imageUrl: String,
+    val tags: String
+)
+
+data class CharacterPersonalityResponse(
+    val trait: String,
+    val description: String
+)
+
+data class CharacterBackgroundResponse(
+    val topic: String,
+    val description: String
+)

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/dto/CharacterHomeResponse.kt

@@ -0,0 +1,33 @@
+package kr.co.vividnext.sodalive.chat.character.dto
+
+data class CharacterMainResponse(
+    val banners: List<CharacterBannerResponse>,
+    val recentCharacters: List<RecentCharacter>,
+    val popularCharacters: List<Character>,
+    val newCharacters: List<Character>,
+    val curationSections: List<CurationSection>
+)
+
+data class CurationSection(
+    val characterCurationId: Long,
+    val title: String,
+    val characters: List<Character>
+)
+
+data class Character(
+    val characterId: Long,
+    val name: String,
+    val description: String,
+    val imageUrl: String
+)
+
+data class RecentCharacter(
+    val characterId: Long,
+    val name: String,
+    val imageUrl: String
+)
+
+data class CharacterBannerResponse(
+    val characterId: Long,
+    val imageUrl: String
+)

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/image/CharacterImage.kt

@@ -0,0 +1,41 @@
+package kr.co.vividnext.sodalive.chat.character.image
+
+import kr.co.vividnext.sodalive.chat.character.ChatCharacter
+import kr.co.vividnext.sodalive.common.BaseEntity
+import javax.persistence.CascadeType
+import javax.persistence.Entity
+import javax.persistence.FetchType
+import javax.persistence.JoinColumn
+import javax.persistence.ManyToOne
+import javax.persistence.OneToMany
+
+@Entity
+class CharacterImage(
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "character_id")
+    var chatCharacter: ChatCharacter,
+
+    // 원본 이미지 경로 (S3 key - content-bucket)
+    var imagePath: String,
+
+    // 블러 이미지 경로 (S3 key - free/public bucket)
+    var blurImagePath: String,
+
+    // 이미지 단독 구매 가격 (단위: can)
+    var imagePriceCan: Long = 0L,
+
+    // 메시지를 통한 가격 (단위: can)
+    var messagePriceCan: Long = 0L,
+
+    // 성인 이미지 여부 (본인인증 필요)
+    var isAdult: Boolean = false,
+
+    // 갤러리/관리자 노출 순서 (낮을수록 먼저)
+    var sortOrder: Int = 0,
+
+    // 활성화 여부 (소프트 삭제)
+    var isActive: Boolean = true
+) : BaseEntity() {
+    @OneToMany(mappedBy = "characterImage", cascade = [CascadeType.ALL], orphanRemoval = true)
+    var triggerMappings: MutableList<CharacterImageTriggerMapping> = mutableListOf()
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/image/CharacterImageController.kt

@@ -0,0 +1,226 @@
+package kr.co.vividnext.sodalive.chat.character.image
+
+import kr.co.vividnext.sodalive.aws.cloudfront.ImageContentCloudFront
+import kr.co.vividnext.sodalive.can.payment.CanPaymentService
+import kr.co.vividnext.sodalive.chat.character.image.dto.CharacterImageListItemResponse
+import kr.co.vividnext.sodalive.chat.character.image.dto.CharacterImageListResponse
+import kr.co.vividnext.sodalive.chat.character.image.dto.CharacterImagePurchaseRequest
+import kr.co.vividnext.sodalive.chat.character.image.dto.CharacterImagePurchaseResponse
+import kr.co.vividnext.sodalive.common.ApiResponse
+import kr.co.vividnext.sodalive.common.SodaException
+import kr.co.vividnext.sodalive.member.Member
+import org.springframework.beans.factory.annotation.Value
+import org.springframework.data.domain.PageRequest
+import org.springframework.security.core.annotation.AuthenticationPrincipal
+import org.springframework.web.bind.annotation.GetMapping
+import org.springframework.web.bind.annotation.PostMapping
+import org.springframework.web.bind.annotation.RequestBody
+import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RequestParam
+import org.springframework.web.bind.annotation.RestController
+
+@RestController
+@RequestMapping("/api/chat/character/image")
+class CharacterImageController(
+    private val imageService: CharacterImageService,
+    private val imageCloudFront: ImageContentCloudFront,
+    private val canPaymentService: CanPaymentService,
+    @Value("\${cloud.aws.cloud-front.host}")
+    private val imageHost: String
+) {
+
+    @GetMapping("/list")
+    fun list(
+        @RequestParam characterId: Long,
+        @RequestParam(required = false, defaultValue = "0") page: Int,
+        @RequestParam(required = false, defaultValue = "20") size: Int,
+        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?
+    ) = run {
+        if (member == null) throw SodaException("로그인 정보를 확인해주세요.")
+        if (member.auth == null) throw SodaException("본인인증을 하셔야 합니다.")
+
+        val pageSize = if (size <= 0) 20 else minOf(size, 20)
+
+        // 전체 활성 이미지 수(프로필 제외) 파악을 위해 최소 페이지 조회
+        val totalActiveElements = imageService.pageActiveByCharacter(characterId, PageRequest.of(0, 1)).totalElements
+        // 프로필 이미지는 무료로 볼 수 있으므로 보유 개수에도 +1 반영
+        val ownedCount = imageService.countOwnedActiveByCharacterForMember(characterId, member.id!!) + 1
+
+        val totalCount = totalActiveElements + 1 // 프로필 포함
+
+        val startIndex = page * pageSize
+        if (startIndex >= totalCount) {
+            return@run ApiResponse.ok(
+                CharacterImageListResponse(
+                    totalCount = totalCount,
+                    ownedCount = ownedCount,
+                    items = emptyList()
+                )
+            )
+        }
+
+        val endExclusive = kotlin.math.min(startIndex + pageSize, totalCount.toInt())
+        val pageLength = endExclusive - startIndex
+
+        // 프로필 이미지 구성(맨 앞)
+        val profilePath = imageService.getCharacterImagePath(characterId) ?: "profile/default-profile.png"
+        val profileItem = CharacterImageListItemResponse(
+            id = 0L,
+            imageUrl = "$imageHost/$profilePath",
+            isOwned = true,
+            imagePriceCan = 0L,
+            sortOrder = 0
+        )
+
+        // 활성 이미지 offset/limit 계산 (결합 리스트 [프로필] + activeImages)
+        val activeOffset = if (startIndex == 0) 0L else (startIndex - 1).toLong()
+        val activeLimit = if (startIndex == 0) (pageLength - 1).toLong() else pageLength.toLong()
+
+        val expiration = 5L * 60L * 1000L // 5분
+        val activeImages = if (activeLimit > 0) {
+            imageService.pageActiveByCharacterOffset(
+                characterId,
+                activeOffset,
+                activeLimit
+            )
+        } else {
+            emptyList()
+        }
+
+        val items = buildList {
+            if (startIndex == 0 && pageLength > 0) add(profileItem)
+            activeImages.forEach { img ->
+                val isOwned = (img.imagePriceCan == 0L) || imageService.isOwnedImageByMember(img.id!!, member.id!!)
+                val url = if (isOwned) {
+                    imageCloudFront.generateSignedURL(img.imagePath, expiration)
+                } else {
+                    "$imageHost/${img.blurImagePath}"
+                }
+                add(
+                    CharacterImageListItemResponse(
+                        id = img.id!!,
+                        imageUrl = url,
+                        isOwned = isOwned,
+                        imagePriceCan = img.imagePriceCan,
+                        sortOrder = img.sortOrder
+                    )
+                )
+            }
+        }
+
+        ApiResponse.ok(
+            CharacterImageListResponse(
+                totalCount = totalCount,
+                ownedCount = ownedCount,
+                items = items
+            )
+        )
+    }
+
+    @GetMapping("/my-list")
+    fun myList(
+        @RequestParam characterId: Long,
+        @RequestParam(required = false, defaultValue = "0") page: Int,
+        @RequestParam(required = false, defaultValue = "20") size: Int,
+        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?
+    ) = run {
+        if (member == null) throw SodaException("로그인 정보를 확인해주세요.")
+        if (member.auth == null) throw SodaException("본인인증을 하셔야 합니다.")
+
+        val pageSize = if (size <= 0) 20 else minOf(size, 20)
+        val expiration = 5L * 60L * 1000L // 5분
+
+        val ownedCount = imageService.countOwnedActiveByCharacterForMember(characterId, member.id!!)
+        val totalCount = ownedCount + 1 // 프로필 포함
+
+        // 빈 페이지 요청 처리
+        val startIndex = page * pageSize
+        if (startIndex >= totalCount) {
+            return@run ApiResponse.ok(
+                CharacterImageListResponse(
+                    totalCount = totalCount,
+                    ownedCount = ownedCount,
+                    items = emptyList()
+                )
+            )
+        }
+
+        val endExclusive = kotlin.math.min(startIndex + pageSize, totalCount.toInt())
+        val pageLength = endExclusive - startIndex
+
+        // 프로필 이미지 경로 및 아이템
+        val profilePath = imageService.getCharacterImagePath(characterId) ?: "profile/default-profile.png"
+        val profileItem = CharacterImageListItemResponse(
+            id = 0L,
+            imageUrl = "$imageHost/$profilePath",
+            isOwned = true,
+            imagePriceCan = 0L,
+            sortOrder = 0
+        )
+
+        // 보유 이미지의 오프셋/리밋 계산 (결합 리스트 [프로필] + ownedImages)
+        val ownedOffset = if (startIndex == 0) 0L else (startIndex - 1).toLong()
+        val ownedLimit = if (startIndex == 0) (pageLength - 1).toLong() else pageLength.toLong()
+
+        val ownedImagesPage = if (ownedLimit > 0) {
+            imageService.pageOwnedActiveByCharacterForMember(characterId, member.id!!, ownedOffset, ownedLimit)
+        } else {
+            emptyList()
+        }
+
+        val items = buildList {
+            if (startIndex == 0 && pageLength > 0) add(profileItem)
+            ownedImagesPage.forEach { img ->
+                val url = imageCloudFront.generateSignedURL(img.imagePath, expiration)
+                add(
+                    CharacterImageListItemResponse(
+                        id = img.id!!,
+                        imageUrl = url,
+                        isOwned = true,
+                        imagePriceCan = img.imagePriceCan,
+                        sortOrder = img.sortOrder
+                    )
+                )
+            }
+        }
+
+        ApiResponse.ok(
+            CharacterImageListResponse(
+                totalCount = totalCount,
+                ownedCount = ownedCount,
+                items = items
+            )
+        )
+    }
+
+    @PostMapping("/purchase")
+    fun purchase(
+        @RequestBody req: CharacterImagePurchaseRequest,
+        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?
+    ) = run {
+        if (member == null) throw SodaException("로그인 정보를 확인해주세요.")
+        if (member.auth == null) throw SodaException("본인인증을 하셔야 합니다.")
+
+        val image = imageService.getById(req.imageId)
+        if (!image.isActive) throw SodaException("비활성화된 이미지입니다.")
+
+        val isOwned = (image.imagePriceCan == 0L) ||
+            imageService.isOwnedImageByMember(image.id!!, member.id!!)
+
+        if (!isOwned) {
+            val needCan = image.imagePriceCan.toInt()
+            if (needCan <= 0) throw SodaException("구매 가격이 잘못되었습니다.")
+
+            canPaymentService.spendCanForCharacterImage(
+                memberId = member.id!!,
+                needCan = needCan,
+                image = image,
+                container = req.container
+            )
+        }
+
+        val expiration = 5L * 60L * 1000L // 5분
+        val signedUrl = imageCloudFront.generateSignedURL(image.imagePath, expiration)
+        ApiResponse.ok(CharacterImagePurchaseResponse(imageUrl = signedUrl))
+    }
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/image/CharacterImageRepository.kt

@@ -0,0 +1,100 @@
+package kr.co.vividnext.sodalive.chat.character.image
+
+import com.querydsl.jpa.JPAExpressions
+import com.querydsl.jpa.impl.JPAQueryFactory
+import kr.co.vividnext.sodalive.can.use.CanUsage
+import kr.co.vividnext.sodalive.can.use.QUseCan.useCan
+import org.springframework.data.domain.Page
+import org.springframework.data.domain.Pageable
+import org.springframework.data.jpa.repository.JpaRepository
+import org.springframework.data.jpa.repository.Query
+import org.springframework.stereotype.Repository
+
+@Repository
+interface CharacterImageRepository : JpaRepository<CharacterImage, Long>, CharacterImageQueryRepository {
+    fun findByChatCharacterIdAndIsActiveTrueOrderBySortOrderAsc(characterId: Long): List<CharacterImage>
+
+    fun findByChatCharacterIdAndIsActiveTrueOrderBySortOrderAsc(
+        characterId: Long,
+        pageable: Pageable
+    ): Page<CharacterImage>
+
+    fun countByChatCharacterIdAndIsActiveTrueAndImagePriceCan(characterId: Long, imagePriceCan: Long): Long
+
+    @Query(
+        "SELECT COALESCE(MAX(ci.sortOrder), 0) FROM CharacterImage ci " +
+            "WHERE ci.chatCharacter.id = :characterId AND ci.isActive = true"
+    )
+    fun findMaxSortOrderByCharacterId(characterId: Long): Int
+}
+
+interface CharacterImageQueryRepository {
+    fun findOwnedActiveImagesByCharacterPaged(
+        characterId: Long,
+        memberId: Long,
+        offset: Long,
+        limit: Long
+    ): List<CharacterImage>
+
+    fun findActiveImagesByCharacterPaged(
+        characterId: Long,
+        offset: Long,
+        limit: Long
+    ): List<CharacterImage>
+}
+
+class CharacterImageQueryRepositoryImpl(
+    private val queryFactory: JPAQueryFactory
+) : CharacterImageQueryRepository {
+    override fun findOwnedActiveImagesByCharacterPaged(
+        characterId: Long,
+        memberId: Long,
+        offset: Long,
+        limit: Long
+    ): List<CharacterImage> {
+        val usages = listOf(CanUsage.CHAT_MESSAGE_PURCHASE, CanUsage.CHARACTER_IMAGE_PURCHASE)
+        val ci = QCharacterImage.characterImage
+        return queryFactory
+            .selectFrom(ci)
+            .where(
+                ci.chatCharacter.id.eq(characterId)
+                    .and(ci.isActive.isTrue)
+                    .and(
+                        ci.imagePriceCan.eq(0L).or(
+                            JPAExpressions
+                                .selectOne()
+                                .from(useCan)
+                                .where(
+                                    useCan.member.id.eq(memberId)
+                                        .and(useCan.isRefund.isFalse)
+                                        .and(useCan.characterImage.id.eq(ci.id))
+                                        .and(useCan.canUsage.`in`(usages))
+                                )
+                                .exists()
+                        )
+                    )
+            )
+            .orderBy(ci.sortOrder.asc(), ci.id.asc())
+            .offset(offset)
+            .limit(limit)
+            .fetch()
+    }
+
+    override fun findActiveImagesByCharacterPaged(
+        characterId: Long,
+        offset: Long,
+        limit: Long
+    ): List<CharacterImage> {
+        val ci = QCharacterImage.characterImage
+        return queryFactory
+            .selectFrom(ci)
+            .where(
+                ci.chatCharacter.id.eq(characterId)
+                    .and(ci.isActive.isTrue)
+            )
+            .orderBy(ci.sortOrder.asc(), ci.id.asc())
+            .offset(offset)
+            .limit(limit)
+            .fetch()
+    }
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/image/CharacterImageService.kt

@@ -0,0 +1,169 @@
+package kr.co.vividnext.sodalive.chat.character.image
+
+// ktlint-disable standard:max-line-length
+import kr.co.vividnext.sodalive.can.use.CanUsage
+import kr.co.vividnext.sodalive.chat.character.repository.ChatCharacterRepository
+import kr.co.vividnext.sodalive.common.SodaException
+import org.springframework.data.domain.Page
+import org.springframework.data.domain.Pageable
+import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
+
+@Service
+class CharacterImageService(
+    private val characterRepository: ChatCharacterRepository,
+    private val imageRepository: CharacterImageRepository,
+    private val triggerTagRepository: CharacterImageTriggerRepository,
+    private val useCanRepository: kr.co.vividnext.sodalive.can.use.UseCanRepository
+) {
+
+    fun listActiveByCharacter(characterId: Long): List<CharacterImage> {
+        return imageRepository.findByChatCharacterIdAndIsActiveTrueOrderBySortOrderAsc(characterId)
+    }
+
+    // 페이징 조회(활성 이미지)
+    fun pageActiveByCharacter(characterId: Long, pageable: Pageable): Page<CharacterImage> {
+        return imageRepository.findByChatCharacterIdAndIsActiveTrueOrderBySortOrderAsc(characterId, pageable)
+    }
+
+    // 오프셋/리밋 조회(활성 이미지)
+    fun pageActiveByCharacterOffset(
+        characterId: Long,
+        offset: Long,
+        limit: Long
+    ): List<CharacterImage> {
+        if (limit <= 0L) return emptyList()
+        return imageRepository.findActiveImagesByCharacterPaged(characterId, offset, limit)
+    }
+
+    // 구매 이력 + 무료로 계산된 보유 수
+    fun countOwnedActiveByCharacterForMember(characterId: Long, memberId: Long): Long {
+        val freeCount = imageRepository.countByChatCharacterIdAndIsActiveTrueAndImagePriceCan(characterId, 0L)
+        val purchasedCount = useCanRepository.countPurchasedActiveImagesByCharacter(
+            memberId,
+            characterId,
+            listOf(
+                CanUsage.CHAT_MESSAGE_PURCHASE,
+                CanUsage.CHARACTER_IMAGE_PURCHASE
+            )
+        )
+        return freeCount + purchasedCount
+    }
+
+    fun isOwnedImageByMember(imageId: Long, memberId: Long): Boolean {
+        // 무료이거나(컨트롤러에서 가격 확인) 구매 이력이 있으면 보유로 판단
+        val purchased = useCanRepository.existsByMember_IdAndIsRefundFalseAndCharacterImage_IdAndCanUsageIn(
+            memberId,
+            imageId,
+            listOf(
+                CanUsage.CHAT_MESSAGE_PURCHASE,
+                CanUsage.CHARACTER_IMAGE_PURCHASE
+            )
+        )
+        return purchased
+    }
+
+    fun getById(id: Long): CharacterImage =
+        imageRepository.findById(id).orElseThrow { SodaException("캐릭터 이미지를 찾을 수 없습니다: $id") }
+
+    fun getCharacterImagePath(characterId: Long): String? {
+        val character = characterRepository.findById(characterId)
+            .orElseThrow { SodaException("캐릭터를 찾을 수 없습니다: $characterId") }
+        return character.imagePath
+    }
+
+    // 보유한(무료+구매) 활성 이미지 페이징 조회
+    fun pageOwnedActiveByCharacterForMember(
+        characterId: Long,
+        memberId: Long,
+        offset: Long,
+        limit: Long
+    ): List<CharacterImage> {
+        if (limit <= 0L) return emptyList()
+        return imageRepository.findOwnedActiveImagesByCharacterPaged(characterId, memberId, offset, limit)
+    }
+
+    @Transactional
+    fun registerImage(
+        characterId: Long,
+        imagePath: String,
+        blurImagePath: String,
+        imagePriceCan: Long,
+        messagePriceCan: Long,
+        isAdult: Boolean,
+        triggers: List<String>
+    ): CharacterImage {
+        val character = characterRepository.findById(characterId)
+            .orElseThrow { SodaException("캐릭터를 찾을 수 없습니다: $characterId") }
+
+        if (imagePriceCan < 0 || messagePriceCan < 0) throw SodaException("가격은 0 can 이상이어야 합니다.")
+
+        if (!character.isActive) throw SodaException("비활성화된 캐릭터에는 이미지를 등록할 수 없습니다: $characterId")
+
+        val nextOrder = (imageRepository.findMaxSortOrderByCharacterId(characterId)) + 1
+        val entity = CharacterImage(
+            chatCharacter = character,
+            imagePath = imagePath,
+            blurImagePath = blurImagePath,
+            imagePriceCan = imagePriceCan,
+            messagePriceCan = messagePriceCan,
+            isAdult = isAdult,
+            sortOrder = nextOrder,
+            isActive = true
+        )
+        val saved = imageRepository.save(entity)
+        applyTriggers(saved, triggers)
+        return saved
+    }
+
+    /**
+     * 수정은 트리거만 가능
+     */
+    @Transactional
+    fun updateTriggers(imageId: Long, triggers: List<String>): CharacterImage {
+        val image = getById(imageId)
+        if (!image.isActive) throw SodaException("비활성화된 이미지는 수정할 수 없습니다: $imageId")
+        applyTriggers(image, triggers)
+        return image
+    }
+
+    private fun applyTriggers(image: CharacterImage, triggers: List<String>) {
+        // 입력 트리거 정규화
+        val newWords = triggers.mapNotNull { it.trim().lowercase().takeIf { s -> s.isNotBlank() } }.distinct().toSet()
+
+        // 현재 매핑 단어 집합
+        val currentMappings = image.triggerMappings
+        val currentWords = currentMappings.map { it.tag.word }.toSet()
+
+        // 제거되어야 할 매핑(현재는 있지만 새 입력에는 없는 단어)
+        val toRemove = currentMappings.filter { it.tag.word !in newWords }
+        currentMappings.removeAll(toRemove)
+
+        // 추가되어야 할 단어(새 입력에는 있지만 현재는 없는 단어)
+        val toAdd = newWords.minus(currentWords)
+        toAdd.forEach { w ->
+            val tag = triggerTagRepository.findByWord(w) ?: triggerTagRepository.save(CharacterImageTrigger(word = w))
+            currentMappings.add(CharacterImageTriggerMapping(characterImage = image, tag = tag))
+        }
+    }
+
+    @Transactional
+    fun deleteImage(imageId: Long) {
+        val image = getById(imageId)
+        image.isActive = false
+    }
+
+    @Transactional
+    fun updateOrders(characterId: Long, ids: List<Long>): List<CharacterImage> {
+        // 동일 캐릭터 소속 검증 및 순서 재지정
+        val updated = mutableListOf<CharacterImage>()
+        ids.forEachIndexed { idx, id ->
+            val img = getById(id)
+            if (img.chatCharacter.id != characterId) throw SodaException("다른 캐릭터의 이미지가 포함되어 있습니다: $id")
+            if (!img.isActive) throw SodaException("비활성화된 이미지는 순서를 변경할 수 없습니다: $id")
+            img.sortOrder = idx + 1
+            updated.add(img)
+        }
+        return updated
+    }
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/image/CharacterImageTrigger.kt

@@ -0,0 +1,24 @@
+package kr.co.vividnext.sodalive.chat.character.image
+
+import kr.co.vividnext.sodalive.common.BaseEntity
+import javax.persistence.Column
+import javax.persistence.Entity
+import javax.persistence.FetchType
+import javax.persistence.OneToMany
+import javax.persistence.Table
+import javax.persistence.UniqueConstraint
+
+/**
+ * 캐릭터 이미지 트리거 "태그" 엔티티
+ * - word를 전역 고유로 관리하여 중복 단어 저장을 방지한다.
+ * - 이미지와의 연결은 CharacterImageTriggerMapping을 사용한다.
+ */
+@Entity
+@Table(uniqueConstraints = [UniqueConstraint(columnNames = ["word"])])
+class CharacterImageTrigger(
+    @Column(nullable = false)
+    var word: String
+) : BaseEntity() {
+    @OneToMany(mappedBy = "tag", fetch = FetchType.LAZY)
+    var mappings: MutableList<CharacterImageTriggerMapping> = mutableListOf()
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/image/CharacterImageTriggerMapping.kt

@@ -0,0 +1,21 @@
+package kr.co.vividnext.sodalive.chat.character.image
+
+import kr.co.vividnext.sodalive.common.BaseEntity
+import javax.persistence.Entity
+import javax.persistence.FetchType
+import javax.persistence.JoinColumn
+import javax.persistence.ManyToOne
+
+/**
+ * CharacterImage 와 CharacterImageTrigger(태그) 사이의 매핑 엔티티
+ */
+@Entity
+class CharacterImageTriggerMapping(
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "character_image_id")
+    var characterImage: CharacterImage,
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "tag_id")
+    var tag: CharacterImageTrigger
+) : BaseEntity()

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/image/CharacterImageTriggerRepository.kt

@@ -0,0 +1,9 @@
+package kr.co.vividnext.sodalive.chat.character.image
+
+import org.springframework.data.jpa.repository.JpaRepository
+import org.springframework.stereotype.Repository
+
+@Repository
+interface CharacterImageTriggerRepository : JpaRepository<CharacterImageTrigger, Long> {
+    fun findByWord(word: String): CharacterImageTrigger?
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/image/dto/CharacterImageListDtos.kt

@@ -0,0 +1,17 @@
+package kr.co.vividnext.sodalive.chat.character.image.dto
+
+import com.fasterxml.jackson.annotation.JsonProperty
+
+data class CharacterImageListItemResponse(
+    @JsonProperty("id") val id: Long,
+    @JsonProperty("imageUrl") val imageUrl: String,
+    @JsonProperty("isOwned") val isOwned: Boolean,
+    @JsonProperty("imagePriceCan") val imagePriceCan: Long,
+    @JsonProperty("sortOrder") val sortOrder: Int
+)
+
+data class CharacterImageListResponse(
+    @JsonProperty("totalCount") val totalCount: Long,
+    @JsonProperty("ownedCount") val ownedCount: Long,
+    @JsonProperty("items") val items: List<CharacterImageListItemResponse>
+)

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/image/dto/CharacterImagePurchaseDtos.kt

@@ -0,0 +1,12 @@
+package kr.co.vividnext.sodalive.chat.character.image.dto
+
+import com.fasterxml.jackson.annotation.JsonProperty
+
+data class CharacterImagePurchaseRequest(
+    @JsonProperty("imageId") val imageId: Long,
+    @JsonProperty("container") val container: String
+)
+
+data class CharacterImagePurchaseResponse(
+    @JsonProperty("imageUrl") val imageUrl: String
+)

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/repository/ChatCharacterBannerRepository.kt

@@ -0,0 +1,18 @@
+package kr.co.vividnext.sodalive.chat.character.repository
+
+import kr.co.vividnext.sodalive.chat.character.ChatCharacterBanner
+import org.springframework.data.domain.Page
+import org.springframework.data.domain.Pageable
+import org.springframework.data.jpa.repository.JpaRepository
+import org.springframework.data.jpa.repository.Query
+import org.springframework.stereotype.Repository
+
+@Repository
+interface ChatCharacterBannerRepository : JpaRepository<ChatCharacterBanner, Long> {
+    // 활성화된 배너 목록 조회 (정렬 순서대로)
+    fun findByIsActiveTrueOrderBySortOrderAsc(pageable: Pageable): Page<ChatCharacterBanner>
+
+    // 활성화된 배너 중 최대 정렬 순서 값 조회
+    @Query("SELECT MAX(b.sortOrder) FROM ChatCharacterBanner b WHERE b.isActive = true")
+    fun findMaxSortOrder(): Int?
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/repository/ChatCharacterGoalRepository.kt

@@ -0,0 +1,10 @@
+package kr.co.vividnext.sodalive.chat.character.repository
+
+import kr.co.vividnext.sodalive.chat.character.ChatCharacterGoal
+import org.springframework.data.jpa.repository.JpaRepository
+import org.springframework.stereotype.Repository
+
+@Repository
+interface ChatCharacterGoalRepository : JpaRepository<ChatCharacterGoal, Long> {
+    fun findByGoal(goal: String): ChatCharacterGoal?
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/repository/ChatCharacterHobbyRepository.kt

@@ -0,0 +1,10 @@
+package kr.co.vividnext.sodalive.chat.character.repository
+
+import kr.co.vividnext.sodalive.chat.character.ChatCharacterHobby
+import org.springframework.data.jpa.repository.JpaRepository
+import org.springframework.stereotype.Repository
+
+@Repository
+interface ChatCharacterHobbyRepository : JpaRepository<ChatCharacterHobby, Long> {
+    fun findByHobby(hobby: String): ChatCharacterHobby?
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/repository/ChatCharacterRepository.kt

@@ -0,0 +1,66 @@
+package kr.co.vividnext.sodalive.chat.character.repository
+
+import kr.co.vividnext.sodalive.chat.character.ChatCharacter
+import org.springframework.data.domain.Page
+import org.springframework.data.domain.Pageable
+import org.springframework.data.jpa.repository.JpaRepository
+import org.springframework.data.jpa.repository.Query
+import org.springframework.data.repository.query.Param
+import org.springframework.stereotype.Repository
+
+@Repository
+interface ChatCharacterRepository : JpaRepository<ChatCharacter, Long> {
+    fun findByCharacterUUID(characterUUID: String): ChatCharacter?
+    fun findByName(name: String): ChatCharacter?
+    fun findByIsActiveTrue(pageable: Pageable): Page<ChatCharacter>
+
+    /**
+     * 활성화된 캐릭터를 생성일 기준 내림차순으로 조회
+     */
+    fun findByIsActiveTrueOrderByCreatedAtDesc(pageable: Pageable): List<ChatCharacter>
+
+    /**
+     * 이름, 설명, MBTI, 태그로 캐릭터 검색
+     */
+    @Query(
+        """
+        SELECT DISTINCT c FROM ChatCharacter c
+        LEFT JOIN c.tagMappings tm
+        LEFT JOIN tm.tag t
+        WHERE c.isActive = true AND
+        (
+            LOWER(c.name) LIKE LOWER(CONCAT('%', :searchTerm, '%')) OR
+            LOWER(c.description) LIKE LOWER(CONCAT('%', :searchTerm, '%')) OR
+            (c.mbti IS NOT NULL AND LOWER(c.mbti) LIKE LOWER(CONCAT('%', :searchTerm, '%'))) OR
+            (t.tag IS NOT NULL AND LOWER(t.tag) LIKE LOWER(CONCAT('%', :searchTerm, '%')))
+        )
+        """
+    )
+    fun searchCharacters(
+        @Param("searchTerm") searchTerm: String,
+        pageable: Pageable
+    ): Page<ChatCharacter>
+
+    /**
+     * 특정 캐릭터와 태그를 공유하는 다른 캐릭터를 무작위로 조회 (현재 캐릭터 제외)
+     */
+    @Query(
+        """
+        SELECT DISTINCT c FROM ChatCharacter c
+        JOIN c.tagMappings tm
+        JOIN tm.tag t
+        WHERE c.isActive = true
+          AND c.id <> :characterId
+          AND t.id IN (
+            SELECT t2.id FROM ChatCharacterTagMapping tm2 JOIN tm2.tag t2 WHERE tm2.chatCharacter.id = :characterId
+          )
+        ORDER BY function('RAND')
+        """
+    )
+    fun findRandomBySharedTags(
+        @Param("characterId") characterId: Long,
+        pageable: Pageable
+    ): List<ChatCharacter>
+
+    fun findByIdInAndIsActiveTrue(ids: List<Long>): List<ChatCharacter>
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/repository/ChatCharacterTagRepository.kt

@@ -0,0 +1,10 @@
+package kr.co.vividnext.sodalive.chat.character.repository
+
+import kr.co.vividnext.sodalive.chat.character.ChatCharacterTag
+import org.springframework.data.jpa.repository.JpaRepository
+import org.springframework.stereotype.Repository
+
+@Repository
+interface ChatCharacterTagRepository : JpaRepository<ChatCharacterTag, Long> {
+    fun findByTag(tag: String): ChatCharacterTag?
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/repository/ChatCharacterValueRepository.kt

@@ -0,0 +1,10 @@
+package kr.co.vividnext.sodalive.chat.character.repository
+
+import kr.co.vividnext.sodalive.chat.character.ChatCharacterValue
+import org.springframework.data.jpa.repository.JpaRepository
+import org.springframework.stereotype.Repository
+
+@Repository
+interface ChatCharacterValueRepository : JpaRepository<ChatCharacterValue, Long> {
+    fun findByValue(value: String): ChatCharacterValue?
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/service/ChatCharacterBannerService.kt

@@ -0,0 +1,134 @@
+package kr.co.vividnext.sodalive.chat.character.service
+
+import kr.co.vividnext.sodalive.chat.character.ChatCharacterBanner
+import kr.co.vividnext.sodalive.chat.character.repository.ChatCharacterBannerRepository
+import kr.co.vividnext.sodalive.chat.character.repository.ChatCharacterRepository
+import kr.co.vividnext.sodalive.common.SodaException
+import org.springframework.data.domain.Page
+import org.springframework.data.domain.Pageable
+import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
+
+@Service
+class ChatCharacterBannerService(
+    private val bannerRepository: ChatCharacterBannerRepository,
+    private val characterRepository: ChatCharacterRepository
+) {
+    /**
+     * 활성화된 모든 배너 조회 (정렬 순서대로)
+     */
+    fun getActiveBanners(pageable: Pageable): Page<ChatCharacterBanner> {
+        return bannerRepository.findByIsActiveTrueOrderBySortOrderAsc(pageable)
+    }
+
+    /**
+     * 배너 상세 조회
+     */
+    fun getBannerById(bannerId: Long): ChatCharacterBanner {
+        return bannerRepository.findById(bannerId)
+            .orElseThrow { SodaException("배너를 찾을 수 없습니다: $bannerId") }
+    }
+
+    /**
+     * 배너 등록
+     *
+     * @param characterId 캐릭터 ID
+     * @param imagePath 이미지 경로
+     * @return 등록된 배너
+     */
+    @Transactional
+    fun registerBanner(characterId: Long, imagePath: String): ChatCharacterBanner {
+        val character = characterRepository.findById(characterId)
+            .orElseThrow { SodaException("캐릭터를 찾을 수 없습니다: $characterId") }
+
+        if (!character.isActive) {
+            throw SodaException("비활성화된 캐릭터에는 배너를 등록할 수 없습니다: $characterId")
+        }
+
+        // 정렬 순서가 지정되지 않은 경우 가장 마지막 순서로 설정
+        val finalSortOrder = (bannerRepository.findMaxSortOrder() ?: 0) + 1
+
+        val banner = ChatCharacterBanner(
+            imagePath = imagePath,
+            chatCharacter = character,
+            sortOrder = finalSortOrder
+        )
+
+        return bannerRepository.save(banner)
+    }
+
+    /**
+     * 배너 수정
+     *
+     * @param bannerId 배너 ID
+     * @param imagePath 이미지 경로 (변경할 경우)
+     * @param characterId 캐릭터 ID (변경할 경우)
+     * @return 수정된 배너
+     */
+    @Transactional
+    fun updateBanner(bannerId: Long, imagePath: String? = null, characterId: Long? = null): ChatCharacterBanner {
+        val banner = bannerRepository.findById(bannerId)
+            .orElseThrow { SodaException("배너를 찾을 수 없습니다: $bannerId") }
+
+        if (!banner.isActive) {
+            throw SodaException("비활성화된 배너는 수정할 수 없습니다: $bannerId")
+        }
+
+        // 이미지 경로 변경
+        if (imagePath != null) {
+            banner.imagePath = imagePath
+        }
+
+        // 캐릭터 변경
+        if (characterId != null) {
+            val character = characterRepository.findById(characterId)
+                .orElseThrow { SodaException("캐릭터를 찾을 수 없습니다: $characterId") }
+
+            if (!character.isActive) {
+                throw SodaException("비활성화된 캐릭터로는 변경할 수 없습니다: $characterId")
+            }
+
+            banner.chatCharacter = character
+        }
+
+        return bannerRepository.save(banner)
+    }
+
+    /**
+     * 배너 삭제 (소프트 삭제)
+     */
+    @Transactional
+    fun deleteBanner(bannerId: Long) {
+        val banner = bannerRepository.findById(bannerId)
+            .orElseThrow { SodaException("배너를 찾을 수 없습니다: $bannerId") }
+
+        banner.isActive = false
+        bannerRepository.save(banner)
+    }
+
+    /**
+     * 배너 정렬 순서 일괄 변경
+     * ID 목록의 순서대로 정렬 순서를 1부터 순차적으로 설정합니다.
+     *
+     * @param ids 배너 ID 목록 (순서대로 정렬됨)
+     * @return 수정된 배너 목록
+     */
+    @Transactional
+    fun updateBannerOrders(ids: List<Long>): List<ChatCharacterBanner> {
+        val updatedBanners = mutableListOf<ChatCharacterBanner>()
+
+        for (index in ids.indices) {
+            val banner = bannerRepository.findById(ids[index])
+                .orElseThrow { SodaException("배너를 찾을 수 없습니다: ${ids[index]}") }
+
+            if (!banner.isActive) {
+                throw SodaException("비활성화된 배너는 수정할 수 없습니다: ${ids[index]}")
+            }
+
+            banner.sortOrder = index + 1
+            updatedBanners.add(bannerRepository.save(banner))
+        }
+
+        return updatedBanners
+    }
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/character/service/ChatCharacterService.kt

@@ -0,0 +1,622 @@
+package kr.co.vividnext.sodalive.chat.character.service
+
+import kr.co.vividnext.sodalive.admin.chat.character.dto.ChatCharacterBackgroundRequest
+import kr.co.vividnext.sodalive.admin.chat.character.dto.ChatCharacterMemoryRequest
+import kr.co.vividnext.sodalive.admin.chat.character.dto.ChatCharacterPersonalityRequest
+import kr.co.vividnext.sodalive.admin.chat.character.dto.ChatCharacterRelationshipRequest
+import kr.co.vividnext.sodalive.admin.chat.character.dto.ChatCharacterUpdateRequest
+import kr.co.vividnext.sodalive.chat.character.CharacterType
+import kr.co.vividnext.sodalive.chat.character.ChatCharacter
+import kr.co.vividnext.sodalive.chat.character.ChatCharacterGoal
+import kr.co.vividnext.sodalive.chat.character.ChatCharacterHobby
+import kr.co.vividnext.sodalive.chat.character.ChatCharacterTag
+import kr.co.vividnext.sodalive.chat.character.ChatCharacterValue
+import kr.co.vividnext.sodalive.chat.character.repository.ChatCharacterGoalRepository
+import kr.co.vividnext.sodalive.chat.character.repository.ChatCharacterHobbyRepository
+import kr.co.vividnext.sodalive.chat.character.repository.ChatCharacterRepository
+import kr.co.vividnext.sodalive.chat.character.repository.ChatCharacterTagRepository
+import kr.co.vividnext.sodalive.chat.character.repository.ChatCharacterValueRepository
+import org.springframework.data.domain.PageRequest
+import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
+
+@Service
+class ChatCharacterService(
+    private val chatCharacterRepository: ChatCharacterRepository,
+    private val tagRepository: ChatCharacterTagRepository,
+    private val valueRepository: ChatCharacterValueRepository,
+    private val hobbyRepository: ChatCharacterHobbyRepository,
+    private val goalRepository: ChatCharacterGoalRepository
+) {
+    /**
+     * 일주일간 대화가 가장 많은 인기 캐릭터 목록 조회
+     * 현재는 채팅방 구현 전이므로 빈 리스트 반환
+     */
+    @Transactional(readOnly = true)
+    fun getPopularCharacters(): List<ChatCharacter> {
+        // 채팅방 구현 전이므로 빈 리스트 반환
+        return emptyList()
+    }
+
+    /**
+     * 최근 등록된 캐릭터 목록 조회 (최대 10개)
+     */
+    @Transactional(readOnly = true)
+    fun getNewCharacters(limit: Int = 10): List<ChatCharacter> {
+        return chatCharacterRepository.findByIsActiveTrueOrderByCreatedAtDesc(PageRequest.of(0, limit))
+    }
+
+    /**
+     * 특정 캐릭터와 태그를 공유하는 다른 캐릭터를 무작위로 조회 (현재 캐릭터 제외)
+     */
+    @Transactional(readOnly = true)
+    fun getOtherCharactersBySharedTags(characterId: Long, limit: Int = 10): List<ChatCharacter> {
+        val others = chatCharacterRepository.findRandomBySharedTags(
+            characterId,
+            PageRequest.of(0, limit)
+        )
+        // 태그 초기화 (지연 로딩 문제 방지)
+        others.forEach { it.tagMappings.size }
+        return others
+    }
+
+    /**
+     * 태그를 찾거나 생성하여 캐릭터에 연결
+     */
+    @Transactional
+    fun addTagToCharacter(chatCharacter: ChatCharacter, tagName: String) {
+        val tag = tagRepository.findByTag(tagName) ?: ChatCharacterTag(tagName)
+        if (tag.id == null) {
+            tagRepository.save(tag)
+        }
+        chatCharacter.addTag(tag)
+    }
+
+    /**
+     * 가치관을 찾거나 생성하여 캐릭터에 연결
+     */
+    @Transactional
+    fun addValueToCharacter(chatCharacter: ChatCharacter, valueName: String) {
+        val value = valueRepository.findByValue(valueName) ?: ChatCharacterValue(valueName)
+        if (value.id == null) {
+            valueRepository.save(value)
+        }
+        chatCharacter.addValue(value)
+    }
+
+    /**
+     * 취미를 찾거나 생성하여 캐릭터에 연결
+     */
+    @Transactional
+    fun addHobbyToCharacter(chatCharacter: ChatCharacter, hobbyName: String) {
+        val hobby = hobbyRepository.findByHobby(hobbyName) ?: ChatCharacterHobby(hobbyName)
+        if (hobby.id == null) {
+            hobbyRepository.save(hobby)
+        }
+        chatCharacter.addHobby(hobby)
+    }
+
+    /**
+     * 목표를 찾거나 생성하여 캐릭터에 연결
+     */
+    @Transactional
+    fun addGoalToCharacter(chatCharacter: ChatCharacter, goalName: String) {
+        val goal = goalRepository.findByGoal(goalName) ?: ChatCharacterGoal(goalName)
+        if (goal.id == null) {
+            goalRepository.save(goal)
+        }
+        chatCharacter.addGoal(goal)
+    }
+
+    /**
+     * 여러 태그를 한번에 캐릭터에 연결
+     */
+    @Transactional
+    fun addTagsToCharacter(chatCharacter: ChatCharacter, tags: List<String>) {
+        tags.distinct().forEach { addTagToCharacter(chatCharacter, it) }
+    }
+
+    /**
+     * 태그 매핑을 증분 업데이트(추가/삭제만)하여 불필요한 매핑 레코드 재생성을 방지
+     */
+    @Transactional
+    fun updateTagsForCharacter(chatCharacter: ChatCharacter, tags: List<String>) {
+        val desired = tags.distinct()
+        // 현재 매핑된 태그 문자열 목록
+        val current = chatCharacter.tagMappings.map { it.tag.tag }
+
+        // 추가가 필요한 태그
+        val toAdd = desired.filterNot { current.contains(it) }
+        toAdd.forEach { addTagToCharacter(chatCharacter, it) }
+
+        // 제거가 필요한 태그 매핑
+        if (chatCharacter.tagMappings.isNotEmpty()) {
+            val iterator = chatCharacter.tagMappings.iterator()
+            while (iterator.hasNext()) {
+                val mapping = iterator.next()
+                if (!desired.contains(mapping.tag.tag)) {
+                    iterator.remove() // orphanRemoval=true 이므로 매핑 엔티티 삭제 처리
+                }
+            }
+        }
+    }
+
+    /**
+     * 여러 가치관을 한번에 캐릭터에 연결
+     */
+    @Transactional
+    fun addValuesToCharacter(chatCharacter: ChatCharacter, values: List<String>) {
+        values.forEach { addValueToCharacter(chatCharacter, it) }
+    }
+
+    /**
+     * 여러 취미를 한번에 캐릭터에 연결
+     */
+    @Transactional
+    fun addHobbiesToCharacter(chatCharacter: ChatCharacter, hobbies: List<String>) {
+        hobbies.forEach { addHobbyToCharacter(chatCharacter, it) }
+    }
+
+    /**
+     * 여러 목표를 한번에 캐릭터에 연결
+     */
+    @Transactional
+    fun addGoalsToCharacter(chatCharacter: ChatCharacter, goals: List<String>) {
+        goals.forEach { addGoalToCharacter(chatCharacter, it) }
+    }
+
+    /**
+     * 가치관 매핑 증분 업데이트
+     */
+    @Transactional
+    fun updateValuesForCharacter(chatCharacter: ChatCharacter, values: List<String>) {
+        val desired = values.distinct()
+        val current = chatCharacter.valueMappings.map { it.value.value }
+        val toAdd = desired.filterNot { current.contains(it) }
+        toAdd.forEach { addValueToCharacter(chatCharacter, it) }
+        if (chatCharacter.valueMappings.isNotEmpty()) {
+            val iterator = chatCharacter.valueMappings.iterator()
+            while (iterator.hasNext()) {
+                val mapping = iterator.next()
+                if (!desired.contains(mapping.value.value)) {
+                    iterator.remove() // orphanRemoval=true 이므로 매핑 엔티티 삭제 처리
+                }
+            }
+        }
+    }
+
+    /**
+     * 취미 매핑 증분 업데이트
+     */
+    @Transactional
+    fun updateHobbiesForCharacter(chatCharacter: ChatCharacter, hobbies: List<String>) {
+        val desired = hobbies.distinct()
+        val current = chatCharacter.hobbyMappings.map { it.hobby.hobby }
+        val toAdd = desired.filterNot { current.contains(it) }
+        toAdd.forEach { addHobbyToCharacter(chatCharacter, it) }
+        if (chatCharacter.hobbyMappings.isNotEmpty()) {
+            val iterator = chatCharacter.hobbyMappings.iterator()
+            while (iterator.hasNext()) {
+                val mapping = iterator.next()
+                if (!desired.contains(mapping.hobby.hobby)) {
+                    iterator.remove() // orphanRemoval=true 이므로 매핑 엔티티 삭제 처리
+                }
+            }
+        }
+    }
+
+    /**
+     * 목표 매핑 증분 업데이트
+     */
+    @Transactional
+    fun updateGoalsForCharacter(chatCharacter: ChatCharacter, goals: List<String>) {
+        val desired = goals.distinct()
+        val current = chatCharacter.goalMappings.map { it.goal.goal }
+        val toAdd = desired.filterNot { current.contains(it) }
+        toAdd.forEach { addGoalToCharacter(chatCharacter, it) }
+        if (chatCharacter.goalMappings.isNotEmpty()) {
+            val iterator = chatCharacter.goalMappings.iterator()
+            while (iterator.hasNext()) {
+                val mapping = iterator.next()
+                if (!desired.contains(mapping.goal.goal)) {
+                    iterator.remove() // orphanRemoval=true 이므로 매핑 엔티티 삭제 처리
+                }
+            }
+        }
+    }
+
+    /**
+     * 기억(memories) 증분 업데이트
+     */
+    @Transactional
+    fun updateMemoriesForCharacter(chatCharacter: ChatCharacter, memories: List<ChatCharacterMemoryRequest>) {
+        val desiredByTitle = memories
+            .asSequence()
+            .distinctBy { it.title }
+            .associateBy { it.title }
+
+        val iterator = chatCharacter.memories.iterator()
+        while (iterator.hasNext()) {
+            val current = iterator.next()
+            val desired = desiredByTitle[current.title]
+            if (desired == null) {
+                // 요청에 없는 항목은 제거
+                iterator.remove()
+            } else {
+                // 값 필드만 in-place 업데이트
+                if (current.content != desired.content) current.content = desired.content
+                if (current.emotion != desired.emotion) current.emotion = desired.emotion
+            }
+        }
+
+        // 신규 추가
+        val existingTitles = chatCharacter.memories.map { it.title }.toSet()
+        desiredByTitle.values
+            .filterNot { existingTitles.contains(it.title) }
+            .forEach { chatCharacter.addMemory(it.title, it.content, it.emotion) }
+    }
+
+    /**
+     * 성격(personalities) 증분 업데이트
+     */
+    @Transactional
+    fun updatePersonalitiesForCharacter(
+        chatCharacter: ChatCharacter,
+        personalities: List<ChatCharacterPersonalityRequest>
+    ) {
+        val desiredByTrait = personalities
+            .asSequence()
+            .distinctBy { it.trait }
+            .associateBy { it.trait }
+
+        val iterator = chatCharacter.personalities.iterator()
+        while (iterator.hasNext()) {
+            val current = iterator.next()
+            val desired = desiredByTrait[current.trait]
+            if (desired == null) {
+                // 요청에 없는 항목은 제거
+                iterator.remove()
+            } else {
+                // 값 필드만 in-place 업데이트
+                if (current.description != desired.description) current.description = desired.description
+            }
+        }
+
+        // 신규 추가
+        val existingTraits = chatCharacter.personalities.map { it.trait }.toSet()
+        desiredByTrait.values
+            .filterNot { existingTraits.contains(it.trait) }
+            .forEach { chatCharacter.addPersonality(it.trait, it.description) }
+    }
+
+    /**
+     * 배경(backgrounds) 증분 업데이트
+     */
+    @Transactional
+    fun updateBackgroundsForCharacter(chatCharacter: ChatCharacter, backgrounds: List<ChatCharacterBackgroundRequest>) {
+        val desiredByTopic = backgrounds
+            .asSequence()
+            .distinctBy { it.topic }
+            .associateBy { it.topic }
+
+        val iterator = chatCharacter.backgrounds.iterator()
+        while (iterator.hasNext()) {
+            val current = iterator.next()
+            val desired = desiredByTopic[current.topic]
+            if (desired == null) {
+                // 요청에 없는 항목은 제거
+                iterator.remove()
+            } else {
+                // 값 필드만 in-place 업데이트
+                if (current.description != desired.description) current.description = desired.description
+            }
+        }
+
+        // 신규 추가
+        val existingTopics = chatCharacter.backgrounds.map { it.topic }.toSet()
+        desiredByTopic.values
+            .filterNot { existingTopics.contains(it.topic) }
+            .forEach { chatCharacter.addBackground(it.topic, it.description) }
+    }
+
+    /**
+     * 관계(relationships) 증분 업데이트
+     */
+    @Transactional
+    fun updateRelationshipsForCharacter(
+        chatCharacter: ChatCharacter,
+        relationships: List<ChatCharacterRelationshipRequest>
+    ) {
+        fun keyOf(p: String, r: String) = "$" + "{" + p + "}" + "::" + "{" + r + "}"
+
+        val desiredByKey = relationships
+            .asSequence()
+            .distinctBy { keyOf(it.personName, it.relationshipName) }
+            .associateBy { keyOf(it.personName, it.relationshipName) }
+
+        val iterator = chatCharacter.relationships.iterator()
+        while (iterator.hasNext()) {
+            val current = iterator.next()
+            val key = keyOf(current.personName, current.relationshipName)
+            val desired = desiredByKey[key]
+            if (desired == null) {
+                iterator.remove()
+            } else {
+                if (current.description != desired.description) current.description = desired.description
+                if (current.importance != desired.importance) current.importance = desired.importance
+                if (current.relationshipType != desired.relationshipType) {
+                    current.relationshipType = desired.relationshipType
+                }
+                if (current.currentStatus != desired.currentStatus) current.currentStatus = desired.currentStatus
+            }
+        }
+
+        val existingKeys = chatCharacter.relationships.map { keyOf(it.personName, it.relationshipName) }.toSet()
+        desiredByKey.values
+            .filterNot { existingKeys.contains(keyOf(it.personName, it.relationshipName)) }
+            .forEach { rr ->
+                chatCharacter.addRelationship(
+                    rr.personName,
+                    rr.relationshipName,
+                    rr.description,
+                    rr.importance,
+                    rr.relationshipType,
+                    rr.currentStatus
+                )
+            }
+    }
+
+    /**
+     * 캐릭터 저장
+     */
+    @Transactional
+    fun saveChatCharacter(chatCharacter: ChatCharacter): ChatCharacter {
+        return chatCharacterRepository.save(chatCharacter)
+    }
+
+    /**
+     * 이름으로 캐릭터 조회
+     */
+    @Transactional(readOnly = true)
+    fun findByName(name: String): ChatCharacter? {
+        return chatCharacterRepository.findByName(name)
+    }
+
+    /**
+     * ID로 캐릭터 조회
+     */
+    @Transactional(readOnly = true)
+    fun findById(id: Long): ChatCharacter? {
+        return chatCharacterRepository.findById(id).orElse(null)
+    }
+
+    /**
+     * 캐릭터 ID로 상세 정보를 조회합니다.
+     * 태그, 가치관, 취미, 목표 등의 관계 정보도 함께 조회합니다.
+     */
+    @Transactional(readOnly = true)
+    fun getCharacterDetail(id: Long): ChatCharacter? {
+        val character = findById(id) ?: return null
+
+        // 지연 로딩된 관계 데이터 초기화
+        character.tagMappings.size
+        character.valueMappings.size
+        character.hobbyMappings.size
+        character.goalMappings.size
+        character.memories.size
+        character.personalities.size
+        character.backgrounds.size
+        character.relationships.size
+
+        return character
+    }
+
+    /**
+     * 캐릭터 생성 및 관련 엔티티 연결
+     */
+    @Transactional
+    fun createChatCharacter(
+        characterUUID: String,
+        name: String,
+        description: String,
+        systemPrompt: String,
+        age: Int? = null,
+        gender: String? = null,
+        mbti: String? = null,
+        speechPattern: String? = null,
+        speechStyle: String? = null,
+        appearance: String? = null,
+        originalTitle: String? = null,
+        originalLink: String? = null,
+        characterType: CharacterType = CharacterType.Character,
+        tags: List<String> = emptyList(),
+        values: List<String> = emptyList(),
+        hobbies: List<String> = emptyList(),
+        goals: List<String> = emptyList()
+    ): ChatCharacter {
+        val chatCharacter = ChatCharacter(
+            characterUUID = characterUUID,
+            name = name,
+            description = description,
+            systemPrompt = systemPrompt,
+            age = age,
+            gender = gender,
+            mbti = mbti,
+            speechPattern = speechPattern,
+            speechStyle = speechStyle,
+            appearance = appearance,
+            originalTitle = originalTitle,
+            originalLink = originalLink,
+            characterType = characterType
+        )
+
+        // 관련 엔티티 연결
+        addTagsToCharacter(chatCharacter, tags)
+        addValuesToCharacter(chatCharacter, values)
+        addHobbiesToCharacter(chatCharacter, hobbies)
+        addGoalsToCharacter(chatCharacter, goals)
+
+        return saveChatCharacter(chatCharacter)
+    }
+
+    /**
+     * 캐릭터 생성 시 기본 정보와 함께 추가 정보도 설정
+     */
+    @Transactional
+    fun createChatCharacterWithDetails(
+        characterUUID: String,
+        name: String,
+        description: String,
+        systemPrompt: String,
+        age: Int? = null,
+        gender: String? = null,
+        mbti: String? = null,
+        speechPattern: String? = null,
+        speechStyle: String? = null,
+        appearance: String? = null,
+        originalTitle: String? = null,
+        originalLink: String? = null,
+        characterType: CharacterType = CharacterType.Character,
+        tags: List<String> = emptyList(),
+        values: List<String> = emptyList(),
+        hobbies: List<String> = emptyList(),
+        goals: List<String> = emptyList(),
+        memories: List<Triple<String, String, String>> = emptyList(),
+        personalities: List<Pair<String, String>> = emptyList(),
+        backgrounds: List<Pair<String, String>> = emptyList(),
+        relationships: List<ChatCharacterRelationshipRequest> = emptyList()
+    ): ChatCharacter {
+        val chatCharacter = createChatCharacter(
+            characterUUID = characterUUID,
+            name = name,
+            description = description,
+            systemPrompt = systemPrompt,
+            age = age,
+            gender = gender,
+            mbti = mbti,
+            speechPattern = speechPattern,
+            speechStyle = speechStyle,
+            appearance = appearance,
+            originalTitle = originalTitle,
+            originalLink = originalLink,
+            characterType = characterType,
+            tags = tags,
+            values = values,
+            hobbies = hobbies,
+            goals = goals
+        )
+
+        // 추가 정보 설정
+        memories.forEach { (title, content, emotion) ->
+            chatCharacter.addMemory(title, content, emotion)
+        }
+
+        personalities.forEach { (trait, description) ->
+            chatCharacter.addPersonality(trait, description)
+        }
+
+        backgrounds.forEach { (topic, description) ->
+            chatCharacter.addBackground(topic, description)
+        }
+
+        relationships.forEach { rr ->
+            chatCharacter.addRelationship(
+                rr.personName,
+                rr.relationshipName,
+                rr.description,
+                rr.importance,
+                rr.relationshipType,
+                rr.currentStatus
+            )
+        }
+
+        return saveChatCharacter(chatCharacter)
+    }
+
+    /**
+     * 캐릭터 수정 시 기본 정보와 함께 추가 정보도 설정
+     * 이름은 변경할 수 없으므로 이름은 변경하지 않음
+     * 변경된 데이터만 업데이트
+     *
+     * @param imagePath 이미지 경로 (null이면 이미지 변경 없음)
+     * @param request 수정 요청 데이터 (id를 제외한 모든 필드는 null 가능)
+     * @return 수정된 ChatCharacter 객체
+     */
+    @Transactional
+    fun updateChatCharacterWithDetails(
+        imagePath: String? = null,
+        request: ChatCharacterUpdateRequest
+    ): ChatCharacter {
+        // 캐릭터 조회
+        val chatCharacter = findById(request.id)
+            ?: throw kr.co.vividnext.sodalive.common.SodaException("해당 ID의 캐릭터를 찾을 수 없습니다: ${request.id}")
+
+        // isActive가 false이면 isActive = false, name = "inactive_$name"으로 변경하고 나머지는 반영하지 않는다.
+        if (request.isActive != null && !request.isActive) {
+            chatCharacter.isActive = false
+
+            val inactiveName = "inactive_${request.name}"
+            val randomSuffix = "_" + java.util.UUID.randomUUID().toString().replace("-", "")
+            chatCharacter.name = inactiveName + randomSuffix
+
+            return saveChatCharacter(chatCharacter)
+        }
+
+        // 이미지 경로가 있으면 설정
+        if (imagePath != null) {
+            chatCharacter.imagePath = imagePath
+        }
+
+        // 기본 필드 업데이트 - 변경된 데이터만 업데이트
+        request.name?.let { chatCharacter.name = it }
+        request.systemPrompt?.let { chatCharacter.systemPrompt = it }
+        request.description?.let { chatCharacter.description = it }
+        request.age?.toIntOrNull()?.let { chatCharacter.age = it }
+        request.gender?.let { chatCharacter.gender = it }
+        request.mbti?.let { chatCharacter.mbti = it }
+        request.speechPattern?.let { chatCharacter.speechPattern = it }
+        request.speechStyle?.let { chatCharacter.speechStyle = it }
+        request.appearance?.let { chatCharacter.appearance = it }
+        request.originalTitle?.let { chatCharacter.originalTitle = it }
+        request.originalLink?.let { chatCharacter.originalLink = it }
+        request.characterType?.let {
+            runCatching { CharacterType.valueOf(it) }.getOrNull()?.let { ct -> chatCharacter.characterType = ct }
+        }
+
+        // request에서 변경된 데이터만 업데이트
+        if (request.tags != null) {
+            updateTagsForCharacter(chatCharacter, request.tags)
+        }
+
+        if (request.values != null) {
+            updateValuesForCharacter(chatCharacter, request.values)
+        }
+
+        if (request.hobbies != null) {
+            updateHobbiesForCharacter(chatCharacter, request.hobbies)
+        }
+
+        if (request.goals != null) {
+            updateGoalsForCharacter(chatCharacter, request.goals)
+        }
+
+        // 추가 정보 설정 - 변경된 데이터만 업데이트
+        if (request.memories != null) {
+            updateMemoriesForCharacter(chatCharacter, request.memories)
+        }
+
+        if (request.personalities != null) {
+            updatePersonalitiesForCharacter(chatCharacter, request.personalities)
+        }
+
+        if (request.backgrounds != null) {
+            updateBackgroundsForCharacter(chatCharacter, request.backgrounds)
+        }
+
+        if (request.relationships != null) {
+            updateRelationshipsForCharacter(chatCharacter, request.relationships)
+        }
+
+        return saveChatCharacter(chatCharacter)
+    }
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/quota/ChatQuota.kt

@@ -0,0 +1,21 @@
+package kr.co.vividnext.sodalive.chat.quota
+
+import java.time.LocalDateTime
+import javax.persistence.Entity
+import javax.persistence.Id
+import javax.persistence.Table
+import javax.persistence.Version
+
+@Entity
+@Table(name = "chat_quota")
+class ChatQuota(
+    @Id
+    val memberId: Long,
+    var remainingFree: Int = 10,
+    var remainingPaid: Int = 0,
+    var nextRechargeAt: LocalDateTime? = null,
+    @Version
+    var version: Long? = null
+) {
+    fun total(): Int = remainingFree + remainingPaid
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/quota/ChatQuotaController.kt

@@ -0,0 +1,63 @@
+package kr.co.vividnext.sodalive.chat.quota
+
+import kr.co.vividnext.sodalive.can.payment.CanPaymentService
+import kr.co.vividnext.sodalive.can.use.CanUsage
+import kr.co.vividnext.sodalive.common.ApiResponse
+import kr.co.vividnext.sodalive.common.SodaException
+import kr.co.vividnext.sodalive.member.Member
+import org.springframework.security.core.annotation.AuthenticationPrincipal
+import org.springframework.web.bind.annotation.GetMapping
+import org.springframework.web.bind.annotation.PostMapping
+import org.springframework.web.bind.annotation.RequestBody
+import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RestController
+
+@RestController
+@RequestMapping("/api/chat/quota")
+class ChatQuotaController(
+    private val chatQuotaService: ChatQuotaService,
+    private val canPaymentService: CanPaymentService
+) {
+
+    data class ChatQuotaStatusResponse(
+        val totalRemaining: Int,
+        val nextRechargeAtEpoch: Long?
+    )
+
+    data class ChatQuotaPurchaseRequest(
+        val container: String
+    )
+
+    @GetMapping("/me")
+    fun getMyQuota(
+        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?
+    ): ApiResponse<ChatQuotaStatusResponse> = run {
+        if (member == null) throw SodaException("로그인 정보를 확인해주세요.")
+        if (member.auth == null) throw SodaException("본인인증을 하셔야 합니다.")
+
+        val s = chatQuotaService.getStatus(member.id!!)
+        ApiResponse.ok(ChatQuotaStatusResponse(s.totalRemaining, s.nextRechargeAtEpochMillis))
+    }
+
+    @PostMapping("/purchase")
+    fun purchaseQuota(
+        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?,
+        @RequestBody request: ChatQuotaPurchaseRequest
+    ): ApiResponse<ChatQuotaStatusResponse> = run {
+        if (member == null) throw SodaException("로그인 정보를 확인해주세요.")
+        if (member.auth == null) throw SodaException("본인인증을 하셔야 합니다.")
+        if (request.container.isBlank()) throw SodaException("container를 확인해주세요.")
+
+        // 30캔 차감 처리 (결제 기록 남김)
+        canPaymentService.spendCan(
+            memberId = member.id!!,
+            needCan = 30,
+            canUsage = CanUsage.CHAT_QUOTA_PURCHASE,
+            container = request.container
+        )
+
+        // 글로벌 유료 개념 제거됨: 구매 성공 시에도 글로벌 쿼터 증액 없음
+        val s = chatQuotaService.getStatus(member.id!!)
+        ApiResponse.ok(ChatQuotaStatusResponse(s.totalRemaining, s.nextRechargeAtEpochMillis))
+    }
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/quota/ChatQuotaRepository.kt

@@ -0,0 +1,15 @@
+package kr.co.vividnext.sodalive.chat.quota
+
+import org.springframework.data.jpa.repository.JpaRepository
+import org.springframework.data.jpa.repository.Lock
+import org.springframework.data.jpa.repository.Query
+import org.springframework.data.repository.query.Param
+import javax.persistence.LockModeType
+
+interface ChatQuotaRepository : JpaRepository<ChatQuota, Long> {
+    @Lock(LockModeType.PESSIMISTIC_WRITE)
+    @Query("select q from ChatQuota q where q.memberId = :memberId")
+    fun findForUpdate(@Param("memberId") memberId: Long): ChatQuota?
+
+    fun findByMemberId(memberId: Long): ChatQuota?
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/quota/ChatQuotaService.kt

@@ -0,0 +1,62 @@
+package kr.co.vividnext.sodalive.chat.quota
+
+import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
+import java.time.Instant
+import java.time.LocalDateTime
+import java.time.ZoneId
+import java.time.ZoneOffset
+
+@Service
+class ChatQuotaService(
+    private val repo: ChatQuotaRepository
+) {
+    companion object {
+        private const val FREE_BUCKET = 40
+    }
+
+    data class QuotaStatus(
+        val totalRemaining: Int,
+        val nextRechargeAtEpochMillis: Long?
+    )
+
+    private fun nextUtc20LocalDateTime(now: Instant = Instant.now()): LocalDateTime {
+        val nowUtc = LocalDateTime.ofInstant(now, ZoneOffset.UTC)
+        val today20 = nowUtc.withHour(20).withMinute(0).withSecond(0).withNano(0)
+        val target = if (nowUtc.isBefore(today20)) today20 else today20.plusDays(1)
+        // 저장은 시스템 기본 타임존의 LocalDateTime으로 보관
+        return LocalDateTime.ofInstant(target.toInstant(ZoneOffset.UTC), ZoneId.systemDefault())
+    }
+
+    @Transactional
+    fun applyRefillOnEnterAndGetStatus(memberId: Long): QuotaStatus {
+        val now = Instant.now()
+        val quota = repo.findForUpdate(memberId) ?: repo.save(ChatQuota(memberId = memberId))
+        // Lazy refill: nextRechargeAt이 없거나 현재를 지났다면 무료 40 회복
+        val nextRecharge = nextUtc20LocalDateTime(now)
+        if (quota.nextRechargeAt == null || !LocalDateTime.now().isBefore(quota.nextRechargeAt)) {
+            quota.remainingFree = FREE_BUCKET
+        }
+        // 다음 UTC20 기준 시간으로 항상 갱신
+        quota.nextRechargeAt = nextRecharge
+
+        val epoch = quota.nextRechargeAt?.atZone(ZoneId.systemDefault())?.toInstant()?.toEpochMilli()
+        // 글로벌은 유료 개념 제거: totalRemaining은 remainingFree만 사용
+        return QuotaStatus(totalRemaining = quota.remainingFree, nextRechargeAtEpochMillis = epoch)
+    }
+
+    @Transactional
+    fun consumeOneFree(memberId: Long) {
+        val quota = repo.findForUpdate(memberId) ?: repo.save(ChatQuota(memberId = memberId))
+        if (quota.remainingFree <= 0) {
+            // 소비 불가: 호출자는 상태 조회로 남은 시간을 판단
+            throw IllegalStateException("No global free quota")
+        }
+        quota.remainingFree -= 1
+    }
+
+    @Transactional
+    fun getStatus(memberId: Long): QuotaStatus {
+        return applyRefillOnEnterAndGetStatus(memberId)
+    }
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/quota/room/ChatRoomQuota.kt

@@ -0,0 +1,19 @@
+package kr.co.vividnext.sodalive.chat.quota.room
+
+import kr.co.vividnext.sodalive.common.BaseEntity
+import javax.persistence.Entity
+import javax.persistence.Table
+import javax.persistence.Version
+
+@Entity
+@Table(name = "chat_room_quota")
+class ChatRoomQuota(
+    val memberId: Long,
+    val chatRoomId: Long,
+    val characterId: Long,
+    var remainingFree: Int = 10,
+    var remainingPaid: Int = 0,
+    var nextRechargeAt: Long? = null,
+    @Version
+    var version: Long? = null
+) : BaseEntity()

src/main/kotlin/kr/co/vividnext/sodalive/chat/quota/room/ChatRoomQuotaController.kt

@@ -0,0 +1,139 @@
+package kr.co.vividnext.sodalive.chat.quota.room
+
+import kr.co.vividnext.sodalive.chat.quota.ChatQuotaService
+import kr.co.vividnext.sodalive.chat.room.ParticipantType
+import kr.co.vividnext.sodalive.chat.room.repository.ChatParticipantRepository
+import kr.co.vividnext.sodalive.chat.room.repository.ChatRoomRepository
+import kr.co.vividnext.sodalive.common.ApiResponse
+import kr.co.vividnext.sodalive.common.SodaException
+import kr.co.vividnext.sodalive.member.Member
+import org.springframework.security.core.annotation.AuthenticationPrincipal
+import org.springframework.web.bind.annotation.GetMapping
+import org.springframework.web.bind.annotation.PathVariable
+import org.springframework.web.bind.annotation.PostMapping
+import org.springframework.web.bind.annotation.RequestBody
+import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RestController
+
+@RestController
+@RequestMapping("/api/chat/rooms")
+class ChatRoomQuotaController(
+    private val chatRoomRepository: ChatRoomRepository,
+    private val participantRepository: ChatParticipantRepository,
+    private val chatRoomQuotaService: ChatRoomQuotaService,
+    private val chatQuotaService: ChatQuotaService
+) {
+
+    data class PurchaseRoomQuotaRequest(
+        val container: String
+    )
+
+    data class PurchaseRoomQuotaResponse(
+        val totalRemaining: Int,
+        val nextRechargeAtEpoch: Long?,
+        val remainingFree: Int,
+        val remainingPaid: Int
+    )
+
+    data class RoomQuotaStatusResponse(
+        val totalRemaining: Int,
+        val nextRechargeAtEpoch: Long?
+    )
+
+    /**
+     * 채팅방 유료 쿼터 구매 API
+     * - 참여 여부 검증(내가 USER로 참여 중인 활성 방)
+     * - 30캔 결제 (UseCan에 chatRoomId:characterId 기록)
+     * - 방 유료 쿼터 40 충전
+     */
+    @PostMapping("/{chatRoomId}/quota/purchase")
+    fun purchaseRoomQuota(
+        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?,
+        @PathVariable chatRoomId: Long,
+        @RequestBody req: PurchaseRoomQuotaRequest
+    ): ApiResponse<PurchaseRoomQuotaResponse> = run {
+        if (member == null) throw SodaException("로그인 정보를 확인해주세요.")
+        if (member.auth == null) throw SodaException("본인인증을 하셔야 합니다.")
+        if (req.container.isBlank()) throw SodaException("container를 확인해주세요.")
+
+        val room = chatRoomRepository.findByIdAndIsActiveTrue(chatRoomId)
+            ?: throw SodaException("채팅방을 찾을 수 없습니다.")
+
+        // 내 참여 여부 확인
+        participantRepository.findByChatRoomAndMemberAndIsActiveTrue(room, member)
+            ?: throw SodaException("잘못된 접근입니다")
+
+        // 캐릭터 참여자 확인(유효한 AI 캐릭터 방인지 체크 및 characterId 기본값 보조)
+        val characterParticipant = participantRepository
+            .findByChatRoomAndParticipantTypeAndIsActiveTrue(room, ParticipantType.CHARACTER)
+            ?: throw SodaException("AI 캐릭터 채팅방이 아닙니다.")
+
+        val character = characterParticipant.character
+            ?: throw SodaException("AI 캐릭터 채팅방이 아닙니다.")
+
+        val characterId = character.id
+            ?: throw SodaException("잘못된 요청입니다. 캐릭터 정보를 확인해주세요.")
+
+        // 서비스에서 결제 포함하여 처리
+        val status = chatRoomQuotaService.purchase(
+            memberId = member.id!!,
+            chatRoomId = chatRoomId,
+            characterId = characterId,
+            addPaid = 40,
+            container = req.container
+        )
+
+        ApiResponse.ok(
+            PurchaseRoomQuotaResponse(
+                totalRemaining = status.totalRemaining,
+                nextRechargeAtEpoch = status.nextRechargeAtEpochMillis,
+                remainingFree = status.remainingFree,
+                remainingPaid = status.remainingPaid
+            )
+        )
+    }
+
+    @GetMapping("/{chatRoomId}/quota/me")
+    fun getMyRoomQuota(
+        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?,
+        @PathVariable chatRoomId: Long
+    ): ApiResponse<RoomQuotaStatusResponse> = run {
+        if (member == null) throw SodaException("로그인 정보를 확인해주세요.")
+        if (member.auth == null) throw SodaException("본인인증을 하셔야 합니다.")
+
+        val room = chatRoomRepository.findByIdAndIsActiveTrue(chatRoomId)
+            ?: throw SodaException("채팅방을 찾을 수 없습니다.")
+        // 내 참여 여부 확인
+        participantRepository.findByChatRoomAndMemberAndIsActiveTrue(room, member)
+            ?: throw SodaException("잘못된 접근입니다")
+        // 캐릭터 확인
+        val characterParticipant = participantRepository
+            .findByChatRoomAndParticipantTypeAndIsActiveTrue(room, ParticipantType.CHARACTER)
+            ?: throw SodaException("AI 캐릭터 채팅방이 아닙니다.")
+        val character = characterParticipant.character
+            ?: throw SodaException("AI 캐릭터 채팅방이 아닙니다.")
+
+        // 글로벌 Lazy refill
+        val globalStatus = chatQuotaService.getStatus(member.id!!)
+
+        // 룸 Lazy refill 상태
+        val roomStatus = chatRoomQuotaService.applyRefillOnEnterAndGetStatus(
+            memberId = member.id!!,
+            chatRoomId = chatRoomId,
+            characterId = character.id!!,
+            globalFree = globalStatus.totalRemaining
+        )
+
+        val next: Long? = when {
+            roomStatus.totalRemaining == 0 -> roomStatus.nextRechargeAtEpochMillis
+            globalStatus.totalRemaining <= 0 -> globalStatus.nextRechargeAtEpochMillis
+            else -> null
+        }
+        ApiResponse.ok(
+            RoomQuotaStatusResponse(
+                totalRemaining = roomStatus.totalRemaining,
+                nextRechargeAtEpoch = next
+            )
+        )
+    }
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/quota/room/ChatRoomQuotaRepository.kt

@@ -0,0 +1,16 @@
+package kr.co.vividnext.sodalive.chat.quota.room
+
+import org.springframework.data.jpa.repository.JpaRepository
+import org.springframework.data.jpa.repository.Lock
+import org.springframework.data.jpa.repository.Query
+import org.springframework.data.repository.query.Param
+import javax.persistence.LockModeType
+
+interface ChatRoomQuotaRepository : JpaRepository<ChatRoomQuota, Long> {
+    @Lock(LockModeType.PESSIMISTIC_WRITE)
+    @Query("select q from ChatRoomQuota q where q.memberId = :memberId and q.chatRoomId = :chatRoomId")
+    fun findForUpdate(
+        @Param("memberId") memberId: Long,
+        @Param("chatRoomId") chatRoomId: Long
+    ): ChatRoomQuota?
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/quota/room/ChatRoomQuotaService.kt

@@ -0,0 +1,172 @@
+package kr.co.vividnext.sodalive.chat.quota.room
+
+import kr.co.vividnext.sodalive.can.payment.CanPaymentService
+import kr.co.vividnext.sodalive.can.use.CanUsage
+import kr.co.vividnext.sodalive.common.SodaException
+import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
+import java.time.Duration
+import java.time.Instant
+
+@Service
+class ChatRoomQuotaService(
+    private val repo: ChatRoomQuotaRepository,
+    private val canPaymentService: CanPaymentService
+) {
+    data class RoomQuotaStatus(
+        val totalRemaining: Int,
+        val nextRechargeAtEpochMillis: Long?,
+        val remainingFree: Int,
+        val remainingPaid: Int
+    )
+
+    private fun calculateAvailableForRoom(globalFree: Int, roomFree: Int, roomPaid: Int): Int {
+        // 유료가 있으면 글로벌 상관 없이 (유료 + 무료동시가능수)로 계산
+        // 무료만 있는 경우에는 글로벌과 룸 Free의 교집합으로 사용 가능 횟수 계산
+        val freeUsable = minOf(globalFree, roomFree)
+        return roomPaid + freeUsable
+    }
+
+    @Transactional
+    fun applyRefillOnEnterAndGetStatus(
+        memberId: Long,
+        chatRoomId: Long,
+        characterId: Long,
+        globalFree: Int
+    ): RoomQuotaStatus {
+        val now = Instant.now()
+        val nowMillis = now.toEpochMilli()
+        val quota = repo.findForUpdate(memberId, chatRoomId) ?: repo.save(
+            ChatRoomQuota(
+                memberId = memberId,
+                chatRoomId = chatRoomId,
+                characterId = characterId,
+                remainingFree = 10,
+                remainingPaid = 0,
+                nextRechargeAt = null
+            )
+        )
+        // Lazy refill: nextRechargeAt이 현재를 지났으면 무료 10으로 리셋하고 next=null
+        if (quota.nextRechargeAt != null && quota.nextRechargeAt!! <= nowMillis) {
+            quota.remainingFree = 10
+            quota.nextRechargeAt = null
+        }
+
+        val total = calculateAvailableForRoom(
+            globalFree = globalFree,
+            roomFree = quota.remainingFree,
+            roomPaid = quota.remainingPaid
+        )
+        return RoomQuotaStatus(
+            totalRemaining = total,
+            nextRechargeAtEpochMillis = quota.nextRechargeAt,
+            remainingFree = quota.remainingFree,
+            remainingPaid = quota.remainingPaid
+        )
+    }
+
+    @Transactional
+    fun consumeOneForSend(
+        memberId: Long,
+        chatRoomId: Long,
+        globalFreeProvider: () -> Int,
+        consumeGlobalFree: () -> Unit
+    ): RoomQuotaStatus {
+        val now = Instant.now()
+        val nowMillis = now.toEpochMilli()
+        val quota = repo.findForUpdate(memberId, chatRoomId)
+            ?: throw SodaException("채팅방을 찾을 수 없습니다.")
+
+        // 충전 시간이 지났다면 무료 10으로 리셋하고 next=null
+        if (quota.nextRechargeAt != null && quota.nextRechargeAt!! <= nowMillis) {
+            quota.remainingFree = 10
+            quota.nextRechargeAt = null
+        }
+
+        // 1) 유료 우선 사용: 글로벌에 영향 없음
+        if (quota.remainingPaid > 0) {
+            quota.remainingPaid -= 1
+            val total = calculateAvailableForRoom(globalFreeProvider(), quota.remainingFree, quota.remainingPaid)
+            return RoomQuotaStatus(total, quota.nextRechargeAt, quota.remainingFree, quota.remainingPaid)
+        }
+
+        // 2) 무료 사용: 글로벌과 룸 동시에 조건 충족 필요
+        val globalFree = globalFreeProvider()
+        if (globalFree <= 0) {
+            // 전송 차단: 글로벌 무료가 0이며 유료도 0 → 전송 불가
+            throw SodaException("무료 쿼터가 소진되었습니다. 글로벌 무료 충전 이후 이용해 주세요.")
+        }
+        if (quota.remainingFree <= 0) {
+            // 전송 차단: 룸 무료가 0이며 유료도 0 → 전송 불가
+            val waitMillis = quota.nextRechargeAt
+            if (waitMillis != null && waitMillis > nowMillis) {
+                throw SodaException("채팅방 무료 쿼터가 소진되었습니다. 무료 충전 이후 이용해 주세요.")
+            } else {
+                throw SodaException("채팅방 무료 쿼터가 소진되었습니다. 잠시 후 다시 시도해 주세요.")
+            }
+        }
+
+        // 둘 다 가능 → 차감
+        consumeGlobalFree()
+        quota.remainingFree -= 1
+        if (quota.remainingFree == 0) {
+            // 무료가 0이 되는 순간 nextRechargeAt = 현재 + 6시간
+            quota.nextRechargeAt = now.plus(Duration.ofHours(6)).toEpochMilli()
+        }
+        val total = calculateAvailableForRoom(globalFreeProvider(), quota.remainingFree, quota.remainingPaid)
+        return RoomQuotaStatus(total, quota.nextRechargeAt, quota.remainingFree, quota.remainingPaid)
+    }
+
+    @Transactional
+    fun purchase(
+        memberId: Long,
+        chatRoomId: Long,
+        characterId: Long,
+        addPaid: Int = 40,
+        container: String
+    ): RoomQuotaStatus {
+        // 요구사항: 30캔 결제 및 UseCan에 방/캐릭터 기록
+        canPaymentService.spendCan(
+            memberId = memberId,
+            needCan = 30,
+            canUsage = CanUsage.CHAT_QUOTA_PURCHASE,
+            chatRoomId = chatRoomId,
+            characterId = characterId,
+            container = container
+        )
+
+        val quota = repo.findForUpdate(memberId, chatRoomId) ?: repo.save(
+            ChatRoomQuota(
+                memberId = memberId,
+                chatRoomId = chatRoomId,
+                characterId = characterId
+            )
+        )
+        quota.remainingPaid += addPaid
+        quota.nextRechargeAt = null
+
+        val total = quota.remainingPaid + quota.remainingFree
+        return RoomQuotaStatus(
+            totalRemaining = total,
+            nextRechargeAtEpochMillis = quota.nextRechargeAt,
+            remainingFree = quota.remainingFree,
+            remainingPaid = quota.remainingPaid
+        )
+    }
+
+    @Transactional
+    fun transferPaid(memberId: Long, fromChatRoomId: Long, toChatRoomId: Long, toCharacterId: Long) {
+        val from = repo.findForUpdate(memberId, fromChatRoomId) ?: return
+        if (from.remainingPaid <= 0) return
+        val to = repo.findForUpdate(memberId, toChatRoomId) ?: repo.save(
+            ChatRoomQuota(
+                memberId = memberId,
+                chatRoomId = toChatRoomId,
+                characterId = toCharacterId
+            )
+        )
+        to.remainingPaid += from.remainingPaid
+        from.remainingPaid = 0
+        // 유료 이관은 룸 무료 충전 시간에 영향을 주지 않음
+    }
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/room/ChatMessage.kt

@@ -0,0 +1,46 @@
+package kr.co.vividnext.sodalive.chat.room
+
+import kr.co.vividnext.sodalive.chat.character.image.CharacterImage
+import kr.co.vividnext.sodalive.common.BaseEntity
+import javax.persistence.Column
+import javax.persistence.Entity
+import javax.persistence.EnumType
+import javax.persistence.Enumerated
+import javax.persistence.FetchType
+import javax.persistence.JoinColumn
+import javax.persistence.ManyToOne
+
+@Entity
+class ChatMessage(
+    // 텍스트 메시지 본문. 현재는 NOT NULL 유지. IMAGE 타입 등 비텍스트 메시지는 빈 문자열("") 저장 방침.
+    @Column(columnDefinition = "TEXT", nullable = false)
+    val message: String,
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "chat_room_id", nullable = false)
+    val chatRoom: ChatRoom,
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "participant_id", nullable = false)
+    val participant: ChatParticipant,
+
+    val isActive: Boolean = true,
+
+    @Enumerated(EnumType.STRING)
+    @Column(name = "message_type", nullable = false)
+    val messageType: ChatMessageType = ChatMessageType.TEXT,
+
+    // 미리 저장된 캐릭터 이미지 참조 (옵션)
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "character_image_id", nullable = true)
+    val characterImage: CharacterImage? = null,
+
+    // 이미지 정적 경로 스냅샷 (옵션)
+    @Column(name = "image_path", nullable = true, length = 1024)
+    val imagePath: String? = null,
+
+    // 메시지 가격 (옵션). 제공되는 경우 1 이상이어야 함.
+    // Bean Validation 사용 시 @field:Min(1) 추가 고려.
+    @Column(name = "price", nullable = true)
+    val price: Int? = null
+) : BaseEntity()

src/main/kotlin/kr/co/vividnext/sodalive/chat/room/ChatMessageType.kt

@@ -0,0 +1,13 @@
+package kr.co.vividnext.sodalive.chat.room
+
+/**
+ * 채팅 메시지 타입
+ * - TEXT: 일반 텍스트 메시지
+ * - IMAGE: 이미지 메시지(캐릭터 이미지 등)
+ *
+ * 유의: 유료 여부는 별도 price 필드로 표현합니다.
+ */
+enum class ChatMessageType {
+    TEXT,
+    IMAGE
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/room/ChatParticipant.kt

@@ -0,0 +1,40 @@
+package kr.co.vividnext.sodalive.chat.room
+
+import kr.co.vividnext.sodalive.chat.character.ChatCharacter
+import kr.co.vividnext.sodalive.common.BaseEntity
+import kr.co.vividnext.sodalive.member.Member
+import javax.persistence.CascadeType
+import javax.persistence.Entity
+import javax.persistence.EnumType
+import javax.persistence.Enumerated
+import javax.persistence.FetchType
+import javax.persistence.JoinColumn
+import javax.persistence.ManyToOne
+import javax.persistence.OneToMany
+
+@Entity
+class ChatParticipant(
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "chat_room_id", nullable = false)
+    val chatRoom: ChatRoom,
+
+    @Enumerated(EnumType.STRING)
+    val participantType: ParticipantType,
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "member_id")
+    val member: Member? = null,
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "character_id")
+    val character: ChatCharacter? = null,
+
+    var isActive: Boolean = true
+) : BaseEntity() {
+    @OneToMany(mappedBy = "participant", cascade = [CascadeType.ALL], fetch = FetchType.LAZY)
+    val messages: MutableList<ChatMessage> = mutableListOf()
+}
+
+enum class ParticipantType {
+    USER, CHARACTER
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/room/ChatRoom.kt

@@ -0,0 +1,20 @@
+package kr.co.vividnext.sodalive.chat.room
+
+import kr.co.vividnext.sodalive.common.BaseEntity
+import javax.persistence.CascadeType
+import javax.persistence.Entity
+import javax.persistence.FetchType
+import javax.persistence.OneToMany
+
+@Entity
+class ChatRoom(
+    val sessionId: String,
+    val title: String,
+    var isActive: Boolean = true
+) : BaseEntity() {
+    @OneToMany(mappedBy = "chatRoom", cascade = [CascadeType.ALL], fetch = FetchType.LAZY)
+    val messages: MutableList<ChatMessage> = mutableListOf()
+
+    @OneToMany(mappedBy = "chatRoom", cascade = [CascadeType.ALL], fetch = FetchType.LAZY)
+    val participants: MutableList<ChatParticipant> = mutableListOf()
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/room/controller/ChatRoomController.kt

@@ -0,0 +1,204 @@
+package kr.co.vividnext.sodalive.chat.room.controller
+
+import kr.co.vividnext.sodalive.chat.room.dto.ChatMessagePurchaseRequest
+import kr.co.vividnext.sodalive.chat.room.dto.ChatRoomResetRequest
+import kr.co.vividnext.sodalive.chat.room.dto.CreateChatRoomRequest
+import kr.co.vividnext.sodalive.chat.room.dto.SendChatMessageRequest
+import kr.co.vividnext.sodalive.chat.room.service.ChatRoomService
+import kr.co.vividnext.sodalive.common.ApiResponse
+import kr.co.vividnext.sodalive.common.SodaException
+import kr.co.vividnext.sodalive.member.Member
+import org.springframework.security.core.annotation.AuthenticationPrincipal
+import org.springframework.web.bind.annotation.GetMapping
+import org.springframework.web.bind.annotation.PathVariable
+import org.springframework.web.bind.annotation.PostMapping
+import org.springframework.web.bind.annotation.RequestBody
+import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RequestParam
+import org.springframework.web.bind.annotation.RestController
+
+@RestController
+@RequestMapping("/api/chat/room")
+class ChatRoomController(
+    private val chatRoomService: ChatRoomService
+) {
+
+    /**
+     * 채팅방 생성 API
+     *
+     * 1. 캐릭터 ID, 유저 ID가 참여 중인 채팅방이 있는지 확인
+     * 2. 있으면 채팅방 ID 반환
+     * 3. 없으면 외부 API 호출
+     * 4. 성공시 외부 API에서 가져오는 sessionId를 포함하여 채팅방 생성
+     * 5. 채팅방 참여자로 캐릭터와 유저 추가
+     * 6. 채팅방 ID 반환
+     *
+     * @param member 인증된 사용자
+     * @param request 채팅방 생성 요청 DTO
+     * @return 채팅방 ID
+     */
+    @PostMapping("/create")
+    fun createChatRoom(
+        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?,
+        @RequestBody request: CreateChatRoomRequest
+    ) = run {
+        if (member == null) throw SodaException("로그인 정보를 확인해주세요.")
+        if (member.auth == null) throw SodaException("본인인증을 하셔야 합니다.")
+
+        val response = chatRoomService.createOrGetChatRoom(member, request.characterId)
+        ApiResponse.ok(response)
+    }
+
+    /**
+     * 내가 참여 중인 채팅방 목록 조회 API
+     * - 페이징(기본 20개)
+     * - 가장 최근 메시지 기준 내림차순
+     */
+    @GetMapping("/list")
+    fun listMyChatRooms(
+        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?,
+        @RequestParam(defaultValue = "0") page: Int
+    ) = run {
+        if (member == null || member.auth == null) {
+            ApiResponse.ok(emptyList())
+        } else {
+            val response = chatRoomService.listMyChatRooms(member, page)
+            ApiResponse.ok(response)
+        }
+    }
+
+    /**
+     * 세션 상태 조회 API
+     * - 채팅방 참여 여부 검증
+     * - 외부 API로 세션 상태 조회 후 active면 true, 아니면 false 반환
+     */
+    @GetMapping("/{chatRoomId}/session")
+    fun getChatSessionStatus(
+        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?,
+        @PathVariable chatRoomId: Long
+    ) = run {
+        if (member == null) throw SodaException("로그인 정보를 확인해주세요.")
+        if (member.auth == null) throw SodaException("본인인증을 하셔야 합니다.")
+
+        val isActive = chatRoomService.isMyRoomSessionActive(member, chatRoomId)
+        ApiResponse.ok(isActive)
+    }
+
+    /**
+     * 채팅방 입장 API
+     * - 참여 여부 검증
+     * - 최신 20개 메시지를 createdAt 오름차순으로 반환
+     */
+    @GetMapping("/{chatRoomId}/enter")
+    fun enterChatRoom(
+        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?,
+        @PathVariable chatRoomId: Long,
+        @RequestParam(required = false) characterImageId: Long?
+    ) = run {
+        if (member == null) throw SodaException("로그인 정보를 확인해주세요.")
+        if (member.auth == null) throw SodaException("본인인증을 하셔야 합니다.")
+
+        val response = chatRoomService.enterChatRoom(member, chatRoomId, characterImageId)
+        ApiResponse.ok(response)
+    }
+
+    /**
+     * 채팅방 나가기 API
+     * - URL에 chatRoomId 포함
+     * - 내가 참여 중인지 확인 (아니면 "잘못된 접근입니다")
+     * - 내 참여자 isActive=false 처리
+     * - 내가 마지막 USER였다면 외부 API로 세션 종료 호출
+     */
+    @PostMapping("/{chatRoomId}/leave")
+    fun leaveChatRoom(
+        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?,
+        @PathVariable chatRoomId: Long
+    ) = run {
+        if (member == null) throw SodaException("로그인 정보를 확인해주세요.")
+        if (member.auth == null) throw SodaException("본인인증을 하셔야 합니다.")
+
+        chatRoomService.leaveChatRoom(member, chatRoomId)
+        ApiResponse.ok(true)
+    }
+
+    /**
+     * 채팅방 메시지 조회 API
+     * - 참여 여부 검증(미참여시 "잘못된 접근입니다")
+     * - cursor(메시지ID)보다 더 과거의 메시지에서 limit만큼 조회(경계 exclusive)
+     * - cursor 미지정 시 최신부터 limit만큼 기준으로 페이징
+     */
+    @GetMapping("/{chatRoomId}/messages")
+    fun getChatMessages(
+        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?,
+        @PathVariable chatRoomId: Long,
+        @RequestParam(defaultValue = "20") limit: Int,
+        @RequestParam(required = false) cursor: Long?
+    ) = run {
+        if (member == null) throw SodaException("로그인 정보를 확인해주세요.")
+        if (member.auth == null) throw SodaException("본인인증을 하셔야 합니다.")
+
+        val response = chatRoomService.getChatMessages(member, chatRoomId, cursor, limit)
+        ApiResponse.ok(response)
+    }
+
+    /**
+     * 채팅방 메시지 전송 API
+     * - 참여 여부 검증(미참여시 "잘못된 접근입니다")
+     * - 외부 API 호출 (/api/chat, POST) 재시도 최대 3회
+     * - 성공 시 내 메시지/캐릭터 메시지 저장 후 캐릭터 메시지 리스트 반환
+     */
+    @PostMapping("/{chatRoomId}/send")
+    fun sendMessage(
+        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?,
+        @PathVariable chatRoomId: Long,
+        @RequestBody request: SendChatMessageRequest
+    ) = run {
+        if (member == null) throw SodaException("로그인 정보를 확인해주세요.")
+        if (member.auth == null) throw SodaException("본인인증을 하셔야 합니다.")
+
+        if (request.message.isBlank()) {
+            ApiResponse.error()
+        } else {
+            ApiResponse.ok(chatRoomService.sendMessage(member, chatRoomId, request.message))
+        }
+    }
+
+    /**
+     * 유료 메시지 구매 API
+     * - 참여 여부 검증
+     * - 이미지 메시지의 경우 이미 보유 시 결제 없이 true 반환
+     * - 그 외 가격 검증 후 CanPaymentService 통해 결제 처리
+     */
+    @PostMapping("/{chatRoomId}/messages/{messageId}/purchase")
+    fun purchaseMessage(
+        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?,
+        @PathVariable chatRoomId: Long,
+        @PathVariable messageId: Long,
+        @RequestBody request: ChatMessagePurchaseRequest
+    ) = run {
+        if (member == null) throw SodaException("로그인 정보를 확인해주세요.")
+        if (member.auth == null) throw SodaException("본인인증을 하셔야 합니다.")
+
+        val result = chatRoomService.purchaseMessage(member, chatRoomId, messageId, request.container)
+        ApiResponse.ok(result)
+    }
+
+    /**
+     * 채팅방 초기화 API
+     * - 로그인 및 본인인증 확인
+     * - 내가 참여 중인 AI 캐릭터 채팅방인지 확인
+     * - 30캔 결제 → 현재 채팅방 나가기 → 동일 캐릭터와 새 채팅방 생성 → 생성된 채팅방 데이터 반환
+     */
+    @PostMapping("/{chatRoomId}/reset")
+    fun resetChatRoom(
+        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?,
+        @PathVariable chatRoomId: Long,
+        @RequestBody request: ChatRoomResetRequest
+    ) = run {
+        if (member == null) throw SodaException("로그인 정보를 확인해주세요.")
+        if (member.auth == null) throw SodaException("본인인증을 하셔야 합니다.")
+
+        val response = chatRoomService.resetChatRoom(member, chatRoomId, request.container)
+        ApiResponse.ok(response)
+    }
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/room/dto/ChatRoomDto.kt

@@ -0,0 +1,205 @@
+package kr.co.vividnext.sodalive.chat.room.dto
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties
+import com.fasterxml.jackson.annotation.JsonProperty
+import kr.co.vividnext.sodalive.chat.character.CharacterType
+import java.time.LocalDateTime
+
+/**
+ * 채팅방 생성 요청 DTO
+ */
+data class CreateChatRoomRequest(
+    val characterId: Long
+)
+
+/**
+ * 채팅방 생성 응답 DTO
+ */
+data class CreateChatRoomResponse(
+    val chatRoomId: Long
+)
+
+/**
+ * 채팅방 목록 아이템 DTO (API 응답용)
+ */
+data class ChatRoomListItemDto(
+    val chatRoomId: Long,
+    val characterId: Long,
+    val title: String,
+    val imageUrl: String,
+    val opponentType: String,
+    val lastMessagePreview: String?,
+    val lastMessageTimeLabel: String
+)
+
+/**
+ * 채팅방 메시지 아이템 DTO (API 응답용)
+ */
+data class ChatMessageItemDto(
+    val messageId: Long,
+    val message: String,
+    val profileImageUrl: String,
+    val mine: Boolean,
+    val createdAt: Long,
+    val messageType: String,
+    val imageUrl: String?,
+    val price: Int?,
+    val hasAccess: Boolean
+)
+
+/**
+ * 채팅방 메시지 페이지 응답 DTO
+ */
+data class ChatMessagesPageResponse(
+    val messages: List<ChatMessageItemDto>,
+    val hasMore: Boolean,
+    val nextCursor: Long?
+)
+
+/**
+ * 채팅방 목록 쿼리 DTO (레포지토리 투영용)
+ */
+
+data class ChatRoomListQueryDto(
+    val chatRoomId: Long,
+    val characterId: Long,
+    val title: String,
+    val imagePath: String?,
+    val characterType: CharacterType,
+    val lastActivityAt: LocalDateTime?
+)
+
+/**
+ * 외부 API 채팅 세션 생성 응답 DTO
+ */
+@JsonIgnoreProperties(ignoreUnknown = true)
+data class ExternalChatSessionCreateResponse(
+    @JsonProperty("success") val success: Boolean,
+    @JsonProperty("data") val data: ExternalChatSessionCreateData?
+)
+
+/**
+ * 외부 API 채팅 세션 생성 데이터 DTO
+ * 공통: sessionId, status
+ * 생성 전용: userId, characterId, character, createdAt
+ */
+@JsonIgnoreProperties(ignoreUnknown = true)
+data class ExternalChatSessionCreateData(
+    @JsonProperty("sessionId") val sessionId: String,
+    @JsonProperty("userId") val userId: String,
+    @JsonProperty("character") val character: ExternalCharacterData,
+    @JsonProperty("status") val status: String,
+    @JsonProperty("createdAt") val createdAt: String,
+    @JsonProperty("message") val message: String?
+)
+
+/**
+ * 외부 API 채팅 세션 조회 응답 DTO
+ */
+@JsonIgnoreProperties(ignoreUnknown = true)
+data class ExternalChatSessionGetResponse(
+    val success: Boolean,
+    val data: ExternalChatSessionGetData?
+)
+
+/**
+ * 외부 API 채팅 세션 조회 데이터 DTO
+ * 세션 조회에서 사용하는 공통 필드만 포함
+ */
+@JsonIgnoreProperties(ignoreUnknown = true)
+data class ExternalChatSessionGetData(
+    @JsonProperty("sessionId") val sessionId: String,
+    @JsonProperty("userId") val userId: String,
+    @JsonProperty("characterId") val characterId: String,
+    @JsonProperty("status") val status: String
+)
+
+/**
+ * 외부 API 캐릭터 데이터 DTO
+ */
+@JsonIgnoreProperties(ignoreUnknown = true)
+data class ExternalCharacterData(
+    @JsonProperty("id") val id: String,
+    @JsonProperty("name") val name: String,
+    @JsonProperty("age") val age: String,
+    @JsonProperty("gender") val gender: String
+)
+
+/**
+ * 채팅 메시지 전송 요청 DTO
+ */
+data class SendChatMessageRequest(
+    val message: String
+)
+
+/**
+ * 유료 메시지 구매 요청 DTO
+ */
+data class ChatMessagePurchaseRequest(
+    val container: String
+)
+
+/**
+ * 외부 API 채팅 전송 응답 DTO
+ */
+@JsonIgnoreProperties(ignoreUnknown = true)
+data class ExternalChatSendResponse(
+    @JsonProperty("success") val success: Boolean,
+    @JsonProperty("data") val data: ExternalChatSendData?
+)
+
+/**
+ * 외부 API 채팅 전송 데이터 DTO
+ */
+@JsonIgnoreProperties(ignoreUnknown = true)
+data class ExternalChatSendData(
+    @JsonProperty("sessionId") val sessionId: String,
+    @JsonProperty("characterResponse") val characterResponse: ExternalCharacterMessage
+)
+
+/**
+ * 외부 API 캐릭터 메시지 DTO
+ */
+@JsonIgnoreProperties(ignoreUnknown = true)
+data class ExternalCharacterMessage(
+    @JsonProperty("id") val id: String,
+    @JsonProperty("content") val content: String,
+    @JsonProperty("timestamp") val timestamp: String,
+    @JsonProperty("messageType") val messageType: String
+)
+
+/**
+ * 채팅방 입장 응답 DTO
+ */
+data class ChatRoomEnterCharacterDto(
+    val characterId: Long,
+    val name: String,
+    val profileImageUrl: String,
+    val characterType: String
+)
+
+data class ChatRoomEnterResponse(
+    val roomId: Long,
+    val character: ChatRoomEnterCharacterDto,
+    val messages: List<ChatMessageItemDto>,
+    val hasMoreMessages: Boolean,
+    val totalRemaining: Int,
+    val nextRechargeAtEpoch: Long?,
+    val bgImageUrl: String? = null
+)
+
+/**
+ * 채팅 메시지 전송 응답 DTO (메시지 + 쿼터 상태)
+ */
+data class SendChatMessageResponse(
+    val messages: List<ChatMessageItemDto>,
+    val totalRemaining: Int,
+    val nextRechargeAtEpoch: Long?
+)
+
+/**
+ * 채팅방 초기화 요청 DTO
+ */
+data class ChatRoomResetRequest(
+    val container: String
+)

src/main/kotlin/kr/co/vividnext/sodalive/chat/room/repository/ChatMessageRepository.kt

@@ -0,0 +1,32 @@
+package kr.co.vividnext.sodalive.chat.room.repository
+
+import kr.co.vividnext.sodalive.chat.room.ChatMessage
+import kr.co.vividnext.sodalive.chat.room.ChatRoom
+import org.springframework.data.domain.Pageable
+import org.springframework.data.jpa.repository.JpaRepository
+import org.springframework.stereotype.Repository
+
+@Repository
+interface ChatMessageRepository : JpaRepository<ChatMessage, Long> {
+    fun findTopByChatRoomAndIsActiveTrueOrderByCreatedAtDesc(chatRoom: ChatRoom): ChatMessage?
+
+    // 기존 20개 고정 메서드는 유지 (기존 호출 호환)
+    fun findTop20ByChatRoomAndIsActiveTrueOrderByIdDesc(chatRoom: ChatRoom): List<ChatMessage>
+
+    fun findTop20ByChatRoomAndIdLessThanAndIsActiveTrueOrderByIdDesc(
+        chatRoom: ChatRoom,
+        id: Long
+    ): List<ChatMessage>
+
+    // 새로운 커서 기반 페이징용 메서드 (limit 가변)
+    fun findByChatRoomAndIsActiveTrueOrderByIdDesc(chatRoom: ChatRoom, pageable: Pageable): List<ChatMessage>
+
+    fun findByChatRoomAndIdLessThanAndIsActiveTrueOrderByIdDesc(
+        chatRoom: ChatRoom,
+        id: Long,
+        pageable: Pageable
+    ): List<ChatMessage>
+
+    // 더 이전 데이터 존재 여부 확인
+    fun existsByChatRoomAndIsActiveTrueAndIdLessThan(chatRoom: ChatRoom, id: Long): Boolean
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/room/repository/ChatParticipantRepository.kt

@@ -0,0 +1,36 @@
+package kr.co.vividnext.sodalive.chat.room.repository
+
+import kr.co.vividnext.sodalive.chat.room.ChatParticipant
+import kr.co.vividnext.sodalive.chat.room.ChatRoom
+import kr.co.vividnext.sodalive.chat.room.ParticipantType
+import kr.co.vividnext.sodalive.member.Member
+import org.springframework.data.jpa.repository.JpaRepository
+import org.springframework.stereotype.Repository
+
+@Repository
+interface ChatParticipantRepository : JpaRepository<ChatParticipant, Long> {
+
+    /**
+     * 특정 채팅방에 참여 중인 멤버 참여자 찾기
+     */
+    fun findByChatRoomAndMemberAndIsActiveTrue(
+        chatRoom: ChatRoom,
+        member: Member
+    ): ChatParticipant?
+
+    /**
+     * 특정 채팅방에 특정 타입(CHARACTER/USER)으로 활성 상태인 참여자 찾기
+     */
+    fun findByChatRoomAndParticipantTypeAndIsActiveTrue(
+        chatRoom: ChatRoom,
+        participantType: ParticipantType
+    ): ChatParticipant?
+
+    /**
+     * 특정 채팅방의 활성 USER 참여자 수
+     */
+    fun countByChatRoomAndParticipantTypeAndIsActiveTrue(
+        chatRoom: ChatRoom,
+        participantType: ParticipantType
+    ): Long
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/room/repository/ChatRoomRepository.kt

@@ -0,0 +1,68 @@
+package kr.co.vividnext.sodalive.chat.room.repository
+
+import kr.co.vividnext.sodalive.chat.character.ChatCharacter
+import kr.co.vividnext.sodalive.chat.room.ChatRoom
+import kr.co.vividnext.sodalive.chat.room.dto.ChatRoomListQueryDto
+import kr.co.vividnext.sodalive.member.Member
+import org.springframework.data.domain.Pageable
+import org.springframework.data.jpa.repository.JpaRepository
+import org.springframework.data.jpa.repository.Query
+import org.springframework.data.repository.query.Param
+import org.springframework.stereotype.Repository
+
+@Repository
+interface ChatRoomRepository : JpaRepository<ChatRoom, Long> {
+
+    /**
+     * 특정 멤버와 캐릭터가 참여 중인 활성화된 채팅방을 찾는 쿼리
+     */
+    @Query(
+        """
+        SELECT DISTINCT r FROM ChatRoom r
+        JOIN r.participants p1
+        JOIN r.participants p2
+        WHERE p1.member = :member AND p1.isActive = true
+        AND p2.character = :character AND p2.isActive = true
+        AND r.isActive = true
+    """
+    )
+    fun findActiveChatRoomByMemberAndCharacter(
+        @Param("member") member: Member,
+        @Param("character") character: ChatCharacter
+    ): ChatRoom?
+
+    /**
+     * 멤버가 참여 중인 채팅방을 최근 메시지 시간 순으로 페이징 조회
+     * - 메시지가 없으면 방 생성 시간(createdAt)으로 대체
+     */
+    @Query(
+        value = """
+            SELECT new kr.co.vividnext.sodalive.chat.room.dto.ChatRoomListQueryDto(
+                r.id,
+                pc.character.id,
+                r.title,
+                pc.character.imagePath,
+                pc.character.characterType,
+                MAX(m.createdAt)
+            )
+            FROM ChatRoom r
+            JOIN r.participants p
+            JOIN r.participants pc
+            JOIN r.messages m
+            WHERE p.member = :member
+              AND p.isActive = true
+              AND pc.participantType = kr.co.vividnext.sodalive.chat.room.ParticipantType.CHARACTER
+              AND pc.isActive = true
+              AND r.isActive = true
+              AND m.isActive = true
+            GROUP BY r.id, r.title, r.createdAt, pc.character.id, pc.character.imagePath, pc.character.characterType
+            ORDER BY MAX(m.createdAt) DESC
+        """
+    )
+    fun findMemberRoomsOrderByLastMessageDesc(
+        @Param("member") member: Member,
+        pageable: Pageable
+    ): List<ChatRoomListQueryDto>
+
+    fun findByIdAndIsActiveTrue(id: Long): ChatRoom?
+}

src/main/kotlin/kr/co/vividnext/sodalive/chat/room/service/ChatRoomService.kt

@@ -0,0 +1,928 @@
+package kr.co.vividnext.sodalive.chat.room.service
+
+import com.fasterxml.jackson.databind.ObjectMapper
+import kr.co.vividnext.sodalive.can.use.CanUsage
+import kr.co.vividnext.sodalive.chat.character.image.CharacterImage
+import kr.co.vividnext.sodalive.chat.character.image.CharacterImageService
+import kr.co.vividnext.sodalive.chat.character.service.ChatCharacterService
+import kr.co.vividnext.sodalive.chat.quota.room.ChatRoomQuotaService
+import kr.co.vividnext.sodalive.chat.room.ChatMessage
+import kr.co.vividnext.sodalive.chat.room.ChatMessageType
+import kr.co.vividnext.sodalive.chat.room.ChatParticipant
+import kr.co.vividnext.sodalive.chat.room.ChatRoom
+import kr.co.vividnext.sodalive.chat.room.ParticipantType
+import kr.co.vividnext.sodalive.chat.room.dto.ChatMessageItemDto
+import kr.co.vividnext.sodalive.chat.room.dto.ChatMessagesPageResponse
+import kr.co.vividnext.sodalive.chat.room.dto.ChatRoomEnterCharacterDto
+import kr.co.vividnext.sodalive.chat.room.dto.ChatRoomEnterResponse
+import kr.co.vividnext.sodalive.chat.room.dto.ChatRoomListItemDto
+import kr.co.vividnext.sodalive.chat.room.dto.ChatRoomListQueryDto
+import kr.co.vividnext.sodalive.chat.room.dto.CreateChatRoomResponse
+import kr.co.vividnext.sodalive.chat.room.dto.ExternalChatSendResponse
+import kr.co.vividnext.sodalive.chat.room.dto.ExternalChatSessionCreateResponse
+import kr.co.vividnext.sodalive.chat.room.dto.ExternalChatSessionGetResponse
+import kr.co.vividnext.sodalive.chat.room.dto.SendChatMessageResponse
+import kr.co.vividnext.sodalive.chat.room.repository.ChatMessageRepository
+import kr.co.vividnext.sodalive.chat.room.repository.ChatParticipantRepository
+import kr.co.vividnext.sodalive.chat.room.repository.ChatRoomRepository
+import kr.co.vividnext.sodalive.common.SodaException
+import kr.co.vividnext.sodalive.member.Member
+import org.slf4j.LoggerFactory
+import org.springframework.beans.factory.annotation.Value
+import org.springframework.data.domain.PageRequest
+import org.springframework.http.HttpEntity
+import org.springframework.http.HttpHeaders
+import org.springframework.http.HttpMethod
+import org.springframework.http.MediaType
+import org.springframework.http.client.SimpleClientHttpRequestFactory
+import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
+import org.springframework.web.client.RestTemplate
+import java.time.Duration
+import java.time.LocalDateTime
+import java.time.ZoneId
+import java.util.UUID
+
+@Service
+class ChatRoomService(
+    private val chatRoomRepository: ChatRoomRepository,
+    private val participantRepository: ChatParticipantRepository,
+    private val messageRepository: ChatMessageRepository,
+    private val characterService: ChatCharacterService,
+    private val characterImageService: CharacterImageService,
+    private val canPaymentService: kr.co.vividnext.sodalive.can.payment.CanPaymentService,
+    private val imageCloudFront: kr.co.vividnext.sodalive.aws.cloudfront.ImageContentCloudFront,
+    private val chatQuotaService: kr.co.vividnext.sodalive.chat.quota.ChatQuotaService,
+    private val chatRoomQuotaService: ChatRoomQuotaService,
+
+    @Value("\${weraser.api-key}")
+    private val apiKey: String,
+
+    @Value("\${weraser.api-url}")
+    private val apiUrl: String,
+
+    @Value("\${server.env}")
+    private val serverEnv: String,
+
+    @Value("\${cloud.aws.cloud-front.host}")
+    private val imageHost: String
+) {
+    private val log = LoggerFactory.getLogger(ChatRoomService::class.java)
+
+    @Transactional
+    fun purchaseMessage(member: Member, chatRoomId: Long, messageId: Long, container: String): ChatMessageItemDto {
+        val room = chatRoomRepository.findByIdAndIsActiveTrue(chatRoomId)
+            ?: throw SodaException("채팅방을 찾을 수 없습니다.")
+        // 참여 여부 검증
+        participantRepository.findByChatRoomAndMemberAndIsActiveTrue(room, member)
+            ?: throw SodaException("잘못된 접근입니다")
+
+        val message = messageRepository.findById(messageId).orElseThrow {
+            SodaException("메시지를 찾을 수 없습니다.")
+        }
+        if (!message.isActive) throw SodaException("비활성화된 메시지입니다.")
+        if (message.chatRoom.id != room.id) throw SodaException("잘못된 접근입니다")
+
+        val price = message.price ?: throw SodaException("구매할 수 없는 메시지입니다.")
+        if (price <= 0) throw SodaException("구매 가격이 잘못되었습니다.")
+
+        // 이미지 메시지인 경우: 이미 소유했다면 결제 생략하고 DTO 반환
+        if (message.messageType == ChatMessageType.IMAGE) {
+            val image = message.characterImage
+            if (image != null) {
+                val alreadyOwned = characterImageService.isOwnedImageByMember(image.id!!, member.id!!)
+                if (alreadyOwned) {
+                    return toChatMessageItemDto(message, member)
+                }
+            }
+        }
+
+        // 결제 진행 및 UseCan 기록 (이미지 메시지면 chatMessage + characterImage 동시 기록됨)
+        canPaymentService.spendCanForChatMessage(
+            memberId = member.id!!,
+            needCan = price,
+            message = message,
+            container = container
+        )
+        // 결제 완료 후 접근 가능 상태로 DTO 반환
+        return toChatMessageItemDto(message, member, forceHasAccess = true)
+    }
+
+    /**
+     * 채팅방 생성 또는 조회
+     *
+     * @param member 멤버
+     * @param characterId 캐릭터 ID
+     * @return 채팅방 ID
+     */
+    @Transactional
+    fun createOrGetChatRoom(member: Member, characterId: Long): CreateChatRoomResponse {
+        // 1. 캐릭터 조회
+        val character = characterService.findById(characterId)
+            ?: throw SodaException("해당 ID의 캐릭터를 찾을 수 없습니다: $characterId")
+
+        // 2. 이미 참여 중인 채팅방이 있는지 확인
+        val existingChatRoom = chatRoomRepository.findActiveChatRoomByMemberAndCharacter(member, character)
+
+        // 3. 있으면 채팅방 ID 반환
+        if (existingChatRoom != null) {
+            return CreateChatRoomResponse(chatRoomId = existingChatRoom.id!!)
+        }
+
+        // 4. 없으면 외부 API 호출하여 세션 생성
+        val userId = generateUserId(member.id!!)
+        val sessionId = callExternalApiForChatSession(userId, character.characterUUID)
+
+        // 5. 채팅방 생성
+        val chatRoom = ChatRoom(
+            sessionId = sessionId,
+            title = character.name,
+            isActive = true
+        )
+        val savedChatRoom = chatRoomRepository.save(chatRoom)
+
+        // 6. 채팅방 참여자 추가 (멤버)
+        val memberParticipant = ChatParticipant(
+            chatRoom = savedChatRoom,
+            participantType = ParticipantType.USER,
+            member = member,
+            character = null,
+            isActive = true
+        )
+        participantRepository.save(memberParticipant)
+
+        // 7. 채팅방 참여자 추가 (캐릭터)
+        val characterParticipant = ChatParticipant(
+            chatRoom = savedChatRoom,
+            participantType = ParticipantType.CHARACTER,
+            member = null,
+            character = character,
+            isActive = true
+        )
+        participantRepository.save(characterParticipant)
+
+        // 8. 채팅방 ID 반환
+        return CreateChatRoomResponse(chatRoomId = savedChatRoom.id!!)
+    }
+
+    /**
+     * 유저 ID 생성
+     * "$serverEnv_user_$유저번호"를 UUID로 변환
+     *
+     * @param memberId 멤버 ID
+     * @return UUID 형태의 유저 ID
+     */
+    private fun generateUserId(memberId: Long): String {
+        val userIdString = "${serverEnv}_user_$memberId"
+        return UUID.nameUUIDFromBytes(userIdString.toByteArray()).toString()
+    }
+
+    /**
+     * 외부 API 호출하여 채팅 세션 생성
+     *
+     * @param userId 유저 ID (UUID)
+     * @param characterUUID 캐릭터 UUID
+     * @return 세션 ID
+     */
+    private fun callExternalApiForChatSession(userId: String, characterUUID: String): String {
+        try {
+            val factory = SimpleClientHttpRequestFactory()
+            factory.setConnectTimeout(20000) // 20초
+            factory.setReadTimeout(20000) // 20초
+
+            val restTemplate = RestTemplate(factory)
+
+            val headers = HttpHeaders()
+            headers.set("x-api-key", apiKey)
+            headers.contentType = MediaType.APPLICATION_JSON
+
+            // 요청 바디 생성 - userId와 characterId 전달
+            val requestBody = mapOf(
+                "userId" to userId,
+                "characterId" to characterUUID
+            )
+
+            val httpEntity = HttpEntity(requestBody, headers)
+
+            val response = restTemplate.exchange(
+                "$apiUrl/api/sessions",
+                HttpMethod.POST,
+                httpEntity,
+                String::class.java
+            )
+
+            // 응답 파싱
+            val objectMapper = ObjectMapper()
+            val apiResponse = objectMapper.readValue(
+                response.body,
+                ExternalChatSessionCreateResponse::class.java
+            )
+
+            // success가 false이면 throw
+            if (!apiResponse.success) {
+                throw SodaException("채팅방 생성에 실패했습니다. 다시 시도해 주세요.")
+            }
+
+            // success가 true이면 파라미터로 넘긴 값과 일치하는지 확인
+            val data = apiResponse.data ?: throw SodaException("채팅방 생성에 실패했습니다. 다시 시도해 주세요.")
+
+            if (data.userId != userId && data.character.id != characterUUID && data.status != "active") {
+                throw SodaException("채팅방 생성에 실패했습니다. 다시 시도해 주세요.")
+            }
+
+            // 세션 ID 반환
+            return data.sessionId
+        } catch (e: Exception) {
+            log.error(e.message)
+            throw SodaException("채팅방 생성에 실패했습니다. 다시 시도해 주세요.")
+        }
+    }
+
+    @Transactional(readOnly = true)
+    fun listMyChatRooms(member: Member, page: Int, size: Int = 20): List<ChatRoomListItemDto> {
+        val pageable = PageRequest.of(if (page < 0) 0 else page, size)
+        val rooms: List<ChatRoomListQueryDto> = chatRoomRepository.findMemberRoomsOrderByLastMessageDesc(
+            member,
+            pageable
+        )
+        return rooms.map { q ->
+            val room = ChatRoom(
+                sessionId = "",
+                title = q.title,
+                isActive = true
+            ).apply { id = q.chatRoomId }
+
+            val latest = messageRepository.findTopByChatRoomAndIsActiveTrueOrderByCreatedAtDesc(room)
+            val preview = if (latest?.message?.isNotBlank() == true) {
+                latest.message.let { msg ->
+                    if (msg.length <= 30) msg else msg.take(30) + "..."
+                }
+            } else {
+                if (latest?.message.isNullOrBlank() && latest?.characterImage != null) {
+                    "[이미지]"
+                } else {
+                    ""
+                }
+            }
+
+            val imageUrl = "$imageHost/${q.imagePath ?: "profile/default-profile.png"}"
+            val opponentType = q.characterType.name // Clone or Character
+            val time = latest?.createdAt ?: q.lastActivityAt
+            val timeLabel = formatRelativeTime(time)
+
+            ChatRoomListItemDto(
+                chatRoomId = q.chatRoomId,
+                characterId = q.characterId,
+                title = q.title,
+                imageUrl = imageUrl,
+                opponentType = opponentType,
+                lastMessagePreview = preview,
+                lastMessageTimeLabel = timeLabel
+            )
+        }
+    }
+
+    private fun formatRelativeTime(time: LocalDateTime?): String {
+        if (time == null) return ""
+        val now = LocalDateTime.now()
+        val duration = Duration.between(time, now)
+        val seconds = duration.seconds
+        if (seconds <= 60) return "방금"
+        val minutes = duration.toMinutes()
+        if (minutes < 60) return "${minutes}분 전"
+        val hours = duration.toHours()
+        if (hours < 24) return "${hours}시간 전"
+        // 그 외: 날짜 (yyyy-MM-dd)
+        return time.toLocalDate().toString()
+    }
+
+    @Transactional(readOnly = true)
+    fun isMyRoomSessionActive(member: Member, chatRoomId: Long): Boolean {
+        val room = chatRoomRepository.findByIdAndIsActiveTrue(chatRoomId)
+            ?: throw SodaException("채팅방을 찾을 수 없습니다.")
+        val participant = participantRepository.findByChatRoomAndMemberAndIsActiveTrue(room, member)
+        if (participant == null) {
+            throw SodaException("잘못된 접근입니다")
+        }
+        return fetchSessionActive(room.sessionId)
+    }
+
+    @Transactional
+    fun enterChatRoom(member: Member, chatRoomId: Long, characterImageId: Long? = null): ChatRoomEnterResponse {
+        // 1) 활성 여부 무관하게 방 조회
+        val baseRoom = chatRoomRepository.findById(chatRoomId).orElseThrow {
+            SodaException("채팅방을 찾을 수 없습니다.")
+        }
+
+        // 2) 기본 방 기준 참여/활성 여부 확인
+        val isActiveRoom = baseRoom.isActive
+        val isMyActiveParticipation =
+            participantRepository.findByChatRoomAndMemberAndIsActiveTrue(baseRoom, member) != null
+
+        // 3) 기본 방의 캐릭터 식별 (활성 우선, 없으면 컬렉션에서 검색)
+        val baseCharacterParticipant = participantRepository.findByChatRoomAndParticipantTypeAndIsActiveTrue(
+            baseRoom,
+            ParticipantType.CHARACTER
+        ) ?: baseRoom.participants.firstOrNull {
+            it.participantType == ParticipantType.CHARACTER
+        } ?: throw SodaException("잘못된 접근입니다")
+
+        val baseCharacter = baseCharacterParticipant.character
+            ?: throw SodaException("오류가 발생했습니다. 다시 시도해 주세요.")
+
+        // 4) 유효한 입장 대상 방 결정
+        val effectiveRoom: ChatRoom = if (isActiveRoom && isMyActiveParticipation) {
+            baseRoom
+        } else {
+            // 동일 캐릭터 + 내가 참여 중인 활성 방을 찾는다
+            val alt = chatRoomRepository.findActiveChatRoomByMemberAndCharacter(member, baseCharacter)
+            alt ?: ( // 대체 방이 없으면 기존과 동일하게 예외 처리
+                if (!isActiveRoom) {
+                    throw SodaException("채팅방을 찾을 수 없습니다.")
+                } else {
+                    throw SodaException("잘못된 접근입니다")
+                }
+                )
+        }
+
+        // 5) 응답 구성 시에는 effectiveRoom의 캐릭터(활성 우선) 사용
+        val characterParticipant = participantRepository.findByChatRoomAndParticipantTypeAndIsActiveTrue(
+            effectiveRoom,
+            ParticipantType.CHARACTER
+        ) ?: effectiveRoom.participants.firstOrNull {
+            it.participantType == ParticipantType.CHARACTER
+        } ?: throw SodaException("잘못된 접근입니다")
+
+        val character = characterParticipant.character
+            ?: throw SodaException("오류가 발생했습니다. 다시 시도해 주세요.")
+
+        val imageUrl = "$imageHost/${character.imagePath ?: "profile/default-profile.png"}"
+        val characterDto = ChatRoomEnterCharacterDto(
+            characterId = character.id!!,
+            name = character.name,
+            profileImageUrl = imageUrl,
+            characterType = character.characterType.name
+        )
+
+        // 메시지 최신 20개 조회 후 createdAt 오름차순으로 반환 (effectiveRoom 기준)
+        val pageable = PageRequest.of(0, 20)
+        val fetched = messageRepository.findByChatRoomAndIsActiveTrueOrderByIdDesc(effectiveRoom, pageable)
+
+        val nextCursor: Long? = fetched.minByOrNull { it.id ?: Long.MAX_VALUE }?.id
+        val hasMore: Boolean = if (nextCursor != null) {
+            messageRepository.existsByChatRoomAndIsActiveTrueAndIdLessThan(effectiveRoom, nextCursor)
+        } else {
+            false
+        }
+
+        val messagesAsc = fetched.sortedBy { it.createdAt }
+        val items = messagesAsc.map { toChatMessageItemDto(it, member) }
+
+        // 5-1) 글로벌 쿼터 Lazy refill
+        val globalStatus = chatQuotaService.applyRefillOnEnterAndGetStatus(member.id!!)
+        // 5-2) 룸 쿼터 Lazy refill + 상태
+        val roomStatus = chatRoomQuotaService.applyRefillOnEnterAndGetStatus(
+            memberId = member.id!!,
+            chatRoomId = effectiveRoom.id!!,
+            characterId = character.id!!,
+            globalFree = globalStatus.totalRemaining
+        )
+
+        // 선택적 캐릭터 이미지 서명 URL 생성 처리
+        // 요구사항: baseRoom이 조건 불만족으로 동일 캐릭터의 내 활성 방으로 라우팅된 경우(bg 이미지 요청 무시)에는 null로 처리
+        val signedUrl: String? =
+            if (effectiveRoom.id != baseRoom.id) {
+                null
+            } else {
+                try {
+                    if (characterImageId != null) {
+                        val img = characterImageService.getById(characterImageId)
+                        // 동일 캐릭터 소속 및 활성 검증
+                        if (img.chatCharacter.id == character.id && img.isActive) {
+                            val owned =
+                                (img.imagePriceCan == 0L) || characterImageService.isOwnedImageByMember(
+                                    img.id!!,
+                                    member.id!!
+                                )
+                            if (owned) {
+                                val expiration = 5L * 60L * 1000L // 5분
+                                imageCloudFront.generateSignedURL(img.imagePath, expiration)
+                            } else {
+                                null
+                            }
+                        } else {
+                            null
+                        }
+                    } else {
+                        null
+                    }
+                } catch (e: Exception) {
+                    // 문제가 있어도 입장 자체는 가능해야 하므로 로그만 남기고 null 반환
+                    log.warn(
+                        "[chat] enter: signed url generation failed. roomId={}, imageId={}, reason={}",
+                        effectiveRoom.id,
+                        characterImageId,
+                        e.message
+                    )
+                    null
+                }
+            }
+
+        // 권고안 + 이슈 보정: 채팅 가능(totalRemaining>0)인 경우 next=null
+        val nextForEnter: Long? = when {
+            // 채팅 가능: 유료>0 또는 무료 동시 사용 가능 → next는 표시하지 않음
+            roomStatus.totalRemaining > 0 -> null
+            // roomPaid==0 && roomFree>0 && global<=0 → 글로벌 next
+            roomStatus.remainingPaid == 0 && roomStatus.remainingFree > 0 && globalStatus.totalRemaining <= 0 ->
+                globalStatus.nextRechargeAtEpochMillis
+            // roomPaid==0 && roomFree==0 → (global<=0) ? max(roomNext, globalNext) : roomNext
+            roomStatus.remainingPaid == 0 && roomStatus.remainingFree == 0 -> {
+                val roomNext = roomStatus.nextRechargeAtEpochMillis
+                val globalNext = globalStatus.nextRechargeAtEpochMillis
+                if (globalStatus.totalRemaining <= 0) {
+                    if (roomNext == null) {
+                        globalNext
+                    } else if (globalNext == null) {
+                        roomNext
+                    } else {
+                        maxOf(roomNext, globalNext)
+                    }
+                } else {
+                    roomNext
+                }
+            }
+            // 그 외 기존 규칙: room total==0 → room next, else if global<=0 → global next, else null
+            roomStatus.totalRemaining == 0 -> roomStatus.nextRechargeAtEpochMillis
+            globalStatus.totalRemaining <= 0 -> globalStatus.nextRechargeAtEpochMillis
+            else -> null
+        }
+        return ChatRoomEnterResponse(
+            roomId = effectiveRoom.id!!,
+            character = characterDto,
+            messages = items,
+            hasMoreMessages = hasMore,
+            totalRemaining = roomStatus.totalRemaining,
+            nextRechargeAtEpoch = nextForEnter,
+            bgImageUrl = signedUrl
+        )
+    }
+
+    private fun fetchSessionActive(sessionId: String): Boolean {
+        try {
+            val factory = SimpleClientHttpRequestFactory()
+            factory.setConnectTimeout(20000) // 20초
+            factory.setReadTimeout(20000) // 20초
+
+            val restTemplate = RestTemplate(factory)
+
+            val headers = HttpHeaders()
+            headers.set("x-api-key", apiKey)
+
+            val httpEntity = HttpEntity(null, headers)
+
+            val response = restTemplate.exchange(
+                "$apiUrl/api/sessions/$sessionId",
+                HttpMethod.GET,
+                httpEntity,
+                String::class.java
+            )
+
+            val objectMapper = ObjectMapper()
+            val apiResponse = objectMapper.readValue(
+                response.body,
+                ExternalChatSessionGetResponse::class.java
+            )
+
+            // success가 false이면 throw
+            if (!apiResponse.success) {
+                throw SodaException("오류가 발생했습니다. 다시 시도해 주세요.")
+            }
+
+            val status = apiResponse.data?.status
+            return status == "active"
+        } catch (e: Exception) {
+            e.printStackTrace()
+            throw SodaException("오류가 발생했습니다. 다시 시도해 주세요.")
+        }
+    }
+
+    @Transactional
+    fun leaveChatRoom(member: Member, chatRoomId: Long, throwOnSessionEndFailure: Boolean = false) {
+        val room = chatRoomRepository.findByIdAndIsActiveTrue(chatRoomId)
+            ?: throw SodaException("채팅방을 찾을 수 없습니다.")
+        val participant = participantRepository.findByChatRoomAndMemberAndIsActiveTrue(room, member)
+            ?: throw SodaException("잘못된 접근입니다")
+
+        // 1) 나가기 처리
+        participant.isActive = false
+        participantRepository.save(participant)
+
+        // 2) 남은 USER 참여자 수 확인
+        val userCount = participantRepository.countByChatRoomAndParticipantTypeAndIsActiveTrue(
+            room,
+            ParticipantType.USER
+        )
+
+        // 3) 내가 마지막 USER였다면 외부 세션 종료
+        if (userCount == 0L) {
+            endExternalSession(room.sessionId, throwOnFailure = throwOnSessionEndFailure)
+            room.isActive = false
+        }
+    }
+
+    private fun endExternalSession(sessionId: String, throwOnFailure: Boolean = false) {
+        // 기본 동작: 내부 재시도. throwOnFailure=true일 때는 최종 실패 시 예외 전파.
+        val maxAttempts = 3
+        var attempt = 0
+        while (attempt < maxAttempts) {
+            attempt++
+            try {
+                val factory = SimpleClientHttpRequestFactory()
+                factory.setConnectTimeout(20000)
+                factory.setReadTimeout(20000)
+
+                val restTemplate = RestTemplate(factory)
+
+                val headers = HttpHeaders()
+                headers.set("x-api-key", apiKey)
+
+                val httpEntity = HttpEntity(null, headers)
+
+                val response = restTemplate.exchange(
+                    "$apiUrl/api/sessions/$sessionId/end",
+                    HttpMethod.PUT,
+                    httpEntity,
+                    String::class.java
+                )
+
+                val objectMapper = ObjectMapper()
+                val node = objectMapper.readTree(response.body)
+                val success = node.get("success")?.asBoolean(false) ?: false
+                if (success) {
+                    log.info("[chat] 외부 세션 종료 성공: sessionId={}, attempt={}", sessionId, attempt)
+                    return
+                } else {
+                    log.warn(
+                        "[chat] 외부 세션 종료 응답 실패: sessionId={}, attempt={}, body={}",
+                        sessionId,
+                        attempt,
+                        response.body
+                    )
+                }
+            } catch (e: Exception) {
+                log.warn("[chat] 외부 세션 종료 중 예외: sessionId={}, attempt={}, message={}", sessionId, attempt, e.message)
+            }
+        }
+        // 최종 실패 처리
+        val message = "채팅방 세션 종료에 실패했습니다. 다시 시도해 주세요."
+        if (throwOnFailure) {
+            log.error("[chat] 외부 세션 종료 최종 실패(예외 전파): sessionId={}, attempts={}", sessionId, maxAttempts)
+            throw SodaException(message)
+        } else {
+            log.error("[chat] 외부 세션 종료 최종 실패: sessionId={}, attempts={}", sessionId, maxAttempts)
+        }
+    }
+
+    @Transactional(readOnly = true)
+    fun getChatMessages(member: Member, chatRoomId: Long, cursor: Long?, limit: Int = 20): ChatMessagesPageResponse {
+        val room = chatRoomRepository.findByIdAndIsActiveTrue(chatRoomId)
+            ?: throw SodaException("채팅방을 찾을 수 없습니다.")
+        participantRepository.findByChatRoomAndMemberAndIsActiveTrue(room, member)
+            ?: throw SodaException("잘못된 접근입니다")
+
+        val pageable = PageRequest.of(0, limit)
+        val fetched = if (cursor != null) {
+            messageRepository.findByChatRoomAndIdLessThanAndIsActiveTrueOrderByIdDesc(room, cursor, pageable)
+        } else {
+            messageRepository.findByChatRoomAndIsActiveTrueOrderByIdDesc(room, pageable)
+        }
+
+        // 가장 오래된 메시지 ID (nextCursor) 및 hasMore 계산
+        val nextCursor: Long? = fetched.minByOrNull { it.id ?: Long.MAX_VALUE }?.id
+        val hasMore: Boolean = if (nextCursor != null) {
+            messageRepository.existsByChatRoomAndIsActiveTrueAndIdLessThan(room, nextCursor)
+        } else {
+            false
+        }
+
+        // createdAt 오름차순으로 정렬하여 반환
+        val messagesAsc = fetched.sortedBy { it.createdAt }
+
+        val items = messagesAsc.map { toChatMessageItemDto(it, member) }
+
+        return ChatMessagesPageResponse(
+            messages = items,
+            hasMore = hasMore,
+            nextCursor = nextCursor
+        )
+    }
+
+    @Transactional
+    fun sendMessage(member: Member, chatRoomId: Long, message: String): SendChatMessageResponse {
+        // 1) 방 존재 확인
+        val room = chatRoomRepository.findByIdAndIsActiveTrue(chatRoomId)
+            ?: throw SodaException("채팅방을 찾을 수 없습니다.")
+        // 2) 참여 여부 확인 (USER)
+        val myParticipant = participantRepository.findByChatRoomAndMemberAndIsActiveTrue(room, member)
+            ?: throw SodaException("잘못된 접근입니다")
+        // 3) 캐릭터 참여자 조회
+        val characterParticipant = participantRepository.findByChatRoomAndParticipantTypeAndIsActiveTrue(
+            room,
+            ParticipantType.CHARACTER
+        ) ?: throw SodaException("잘못된 접근입니다")
+
+        val character = characterParticipant.character
+            ?: throw SodaException("오류가 발생했습니다. 다시 시도해 주세요.")
+
+        // 4) 외부 API 호출 준비
+        val userId = generateUserId(member.id!!)
+        val sessionId = room.sessionId
+        val characterUUID = character.characterUUID
+
+        // 5) 쿼터 확인 및 차감 (유료 우선, 무료 사용 시 글로벌과 룸 동시 차감)
+        val roomQuotaAfterConsume = chatRoomQuotaService.consumeOneForSend(
+            memberId = member.id!!,
+            chatRoomId = room.id!!,
+            globalFreeProvider = { chatQuotaService.getStatus(member.id!!).totalRemaining },
+            consumeGlobalFree = { chatQuotaService.consumeOneFree(member.id!!) }
+        )
+
+        // 6) 외부 API 호출 (최대 3회 재시도)
+        val characterReply = callExternalApiForChatSendWithRetry(userId, characterUUID, message, sessionId)
+
+        // 6) 내 메시지 저장
+        val myMsgEntity = ChatMessage(
+            message = message,
+            chatRoom = room,
+            participant = myParticipant,
+            isActive = true
+        )
+        messageRepository.save(myMsgEntity)
+
+        // 7) 캐릭터 텍스트 메시지 항상 저장
+        val characterTextMsg = messageRepository.save(
+            ChatMessage(
+                message = characterReply,
+                chatRoom = room,
+                participant = characterParticipant,
+                isActive = true
+            )
+        )
+
+        // 응답 프로필 이미지 URL 공통 구성
+        val profilePath = characterParticipant.character?.imagePath
+        val defaultPath = profilePath ?: "profile/default-profile.png"
+        val senderImageUrl = "$imageHost/$defaultPath"
+
+        val textDto = ChatMessageItemDto(
+            messageId = characterTextMsg.id!!,
+            message = characterTextMsg.message,
+            profileImageUrl = senderImageUrl,
+            mine = false,
+            createdAt = characterTextMsg.createdAt?.atZone(ZoneId.systemDefault())?.toInstant()
+                ?.toEpochMilli()
+                ?: 0L,
+            messageType = ChatMessageType.TEXT.name,
+            imageUrl = null,
+            price = null,
+            hasAccess = true
+        )
+
+        // 발송 후 최신 잔여 수량 및 next 계산 규칙 적용
+        val statusTotalRemaining = roomQuotaAfterConsume.totalRemaining
+        val globalAfter = chatQuotaService.getStatus(member.id!!)
+        val statusNextRechargeAt: Long? = when {
+            // 채팅 가능: totalRemaining>0 → next 표시하지 않음
+            statusTotalRemaining > 0 -> null
+            // totalRemaining==0이고 (global<=0) → max(roomNext, globalNext)
+            statusTotalRemaining == 0 && globalAfter.totalRemaining <= 0 -> {
+                val roomNext = roomQuotaAfterConsume.nextRechargeAtEpochMillis
+                val globalNext = globalAfter.nextRechargeAtEpochMillis
+                if (roomNext == null) globalNext else if (globalNext == null) roomNext else maxOf(roomNext, globalNext)
+            }
+
+            statusTotalRemaining == 0 -> roomQuotaAfterConsume.nextRechargeAtEpochMillis
+            globalAfter.totalRemaining <= 0 -> globalAfter.nextRechargeAtEpochMillis
+            else -> null
+        }
+
+        // 8) 트리거 매칭 → 이미지 메시지 추가 저장(있을 경우)
+        val matchedImage = findTriggeredCharacterImage(character.id!!, characterReply)
+        if (matchedImage != null) {
+            val owned = characterImageService.isOwnedImageByMember(matchedImage.id!!, member.id!!)
+            val priceInt: Int? = if (owned) {
+                null
+            } else {
+                val p = matchedImage.messagePriceCan
+                if (p <= 0L) null else if (p > Int.MAX_VALUE) Int.MAX_VALUE else p.toInt()
+            }
+            // 보유하지 않은 경우 블러 이미지로 전송
+            val snapshotPath = if (owned) matchedImage.imagePath else matchedImage.blurImagePath
+            val imageMsg = messageRepository.save(
+                ChatMessage(
+                    message = "",
+                    chatRoom = room,
+                    participant = characterParticipant,
+                    isActive = true,
+                    messageType = ChatMessageType.IMAGE,
+                    characterImage = matchedImage,
+                    imagePath = snapshotPath,
+                    price = priceInt
+                )
+            )
+
+            val imageDto = toChatMessageItemDto(imageMsg, member)
+            return SendChatMessageResponse(
+                messages = listOf(textDto, imageDto),
+                totalRemaining = statusTotalRemaining,
+                nextRechargeAtEpoch = statusNextRechargeAt
+            )
+        }
+
+        return SendChatMessageResponse(
+            messages = listOf(textDto),
+            totalRemaining = statusTotalRemaining,
+            nextRechargeAtEpoch = statusNextRechargeAt
+        )
+    }
+
+    private fun toChatMessageItemDto(
+        msg: ChatMessage,
+        member: Member,
+        forceHasAccess: Boolean = false
+    ): ChatMessageItemDto {
+        val sender = msg.participant
+        val profilePath = when (sender.participantType) {
+            ParticipantType.USER -> sender.member?.profileImage
+            ParticipantType.CHARACTER -> sender.character?.imagePath
+        }
+        val senderImageUrl = "$imageHost/${profilePath ?: "profile/default-profile.png"}"
+        val createdAtMillis = msg.createdAt?.atZone(ZoneId.systemDefault())?.toInstant()?.toEpochMilli() ?: 0L
+        val hasAccess = if (forceHasAccess) {
+            true
+        } else if (msg.messageType == ChatMessageType.IMAGE) {
+            if (msg.price == null) {
+                true
+            } else {
+                msg.characterImage?.id?.let {
+                    characterImageService.isOwnedImageByMember(it, member.id!!)
+                } ?: true
+            }
+        } else {
+            true
+        }
+        val expirationMs = 5L * 60L * 1000L
+        val resolvedImageUrl: String? = if (msg.messageType == ChatMessageType.IMAGE) {
+            val path = if (hasAccess) {
+                msg.characterImage?.imagePath ?: msg.imagePath
+            } else {
+                msg.imagePath
+            }
+            path?.let { p ->
+                if (hasAccess) {
+                    imageCloudFront.generateSignedURL(p, expirationMs)
+                } else {
+                    "$imageHost/$p"
+                }
+            }
+        } else {
+            null
+        }
+        return ChatMessageItemDto(
+            messageId = msg.id!!,
+            message = msg.message,
+            profileImageUrl = senderImageUrl,
+            mine = sender.member?.id == member.id,
+            createdAt = createdAtMillis,
+            messageType = msg.messageType.name,
+            imageUrl = resolvedImageUrl,
+            price = msg.price,
+            hasAccess = hasAccess
+        )
+    }
+
+    private fun callExternalApiForChatSendWithRetry(
+        userId: String,
+        characterUUID: String,
+        message: String,
+        sessionId: String
+    ): String {
+        val maxAttempts = 3
+        var attempt = 0
+        while (attempt < maxAttempts) {
+            attempt++
+            try {
+                return callExternalApiForChatSend(userId, characterUUID, message, sessionId)
+            } catch (e: Exception) {
+                log.warn("[chat] 외부 채팅 전송 실패 attempt={}, error={}", attempt, e.message)
+            }
+        }
+        log.error("[chat] 외부 채팅 전송 최종 실패 attempts={}", maxAttempts)
+        throw SodaException("메시지 전송을 실패했습니다.")
+    }
+
+    private fun callExternalApiForChatSend(
+        userId: String,
+        characterUUID: String,
+        message: String,
+        sessionId: String
+    ): String {
+        val factory = SimpleClientHttpRequestFactory()
+        factory.setConnectTimeout(20000)
+        factory.setReadTimeout(20000)
+
+        val restTemplate = RestTemplate(factory)
+
+        val headers = HttpHeaders()
+        headers.set("x-api-key", apiKey)
+        headers.contentType = MediaType.APPLICATION_JSON
+
+        val requestBody = mapOf(
+            "userId" to userId,
+            "characterId" to characterUUID,
+            "message" to message,
+            "sessionId" to sessionId
+        )
+
+        val httpEntity = HttpEntity(requestBody, headers)
+
+        val response = restTemplate.exchange(
+            "$apiUrl/api/chat",
+            HttpMethod.POST,
+            httpEntity,
+            String::class.java
+        )
+
+        val objectMapper = ObjectMapper()
+        val apiResponse = objectMapper.readValue(
+            response.body,
+            ExternalChatSendResponse::class.java
+        )
+
+        if (!apiResponse.success) {
+            throw SodaException("메시지 전송을 실패했습니다.")
+        }
+        val data = apiResponse.data ?: throw SodaException("메시지 전송을 실패했습니다.")
+        val characterContent = data.characterResponse.content
+        if (characterContent.isBlank()) {
+            throw SodaException("메시지 전송을 실패했습니다.")
+        }
+        return characterContent
+    }
+
+    private fun findTriggeredCharacterImage(characterId: Long, replyText: String): CharacterImage? {
+        val text = replyText.lowercase()
+        val images: List<CharacterImage> = characterImageService.listActiveByCharacter(characterId)
+        for (img in images) {
+            val triggers = img.triggerMappings
+                .map { it.tag.word.trim().lowercase() }
+                .filter { it.isNotBlank() }
+            if (triggers.isEmpty()) continue
+            val allIncluded = triggers.all { t -> text.contains(t) }
+            if (allIncluded) return img
+        }
+        return null
+    }
+
+    @Transactional
+    fun resetChatRoom(member: Member, chatRoomId: Long, container: String): CreateChatRoomResponse {
+        // 0) 방 존재 및 내 참여 여부 확인
+        val room = chatRoomRepository.findByIdAndIsActiveTrue(chatRoomId)
+            ?: throw SodaException("채팅방을 찾을 수 없습니다.")
+        participantRepository.findByChatRoomAndMemberAndIsActiveTrue(room, member)
+            ?: throw SodaException("잘못된 접근입니다")
+
+        // 1) AI 캐릭터 채팅방인지 확인 (CHARACTER 타입의 활성 참여자 존재 확인)
+        val characterParticipant = participantRepository
+            .findByChatRoomAndParticipantTypeAndIsActiveTrue(room, ParticipantType.CHARACTER)
+            ?: throw SodaException("AI 캐릭터 채팅방이 아닙니다.")
+        val character = characterParticipant.character
+            ?: throw SodaException("AI 캐릭터 채팅방이 아닙니다.")
+
+        // 2) 30캔 결제 (채팅방 초기화 전용 CanUsage 사용)
+        canPaymentService.spendCan(
+            memberId = member.id!!,
+            needCan = 30,
+            canUsage = CanUsage.CHAT_ROOM_RESET,
+            chatRoomId = chatRoomId,
+            characterId = character.id!!,
+            container = container
+        )
+
+        // 3) 현재 채팅방 나가기 (세션 종료 실패 시 롤백되도록 설정)
+        leaveChatRoom(member, chatRoomId, true)
+
+        // 4) 동일한 캐릭터와 새로운 채팅방 생성
+        val created = createOrGetChatRoom(member, character.id!!)
+
+        // 5) 신규 채팅방 생성 성공 시: 기존 방의 유료 쿼터를 새 방으로 이관
+        chatRoomQuotaService.transferPaid(
+            memberId = member.id!!,
+            fromChatRoomId = chatRoomId,
+            toChatRoomId = created.chatRoomId,
+            toCharacterId = character.id!!
+        )
+        // 글로벌 무료 쿼터는 UTC 20:00 기준 lazy 충전이므로 별도의 초기화 불필요
+        return created
+    }
+}

src/main/kotlin/kr/co/vividnext/sodalive/configs/SecurityConfig.kt

@@ -93,6 +93,8 @@ class SecurityConfig(
             .antMatchers(HttpMethod.GET, "/live/recommend").permitAll()
             .antMatchers("/ad-tracking/app-launch").permitAll()
             .antMatchers(HttpMethod.GET, "/notice/latest").permitAll()
+            .antMatchers(HttpMethod.GET, "/api/chat/character/main").permitAll()
+            .antMatchers(HttpMethod.GET, "/api/chat/room/list").permitAll()
             .anyRequest().authenticated()
             .and()
             .build()

src/main/kotlin/kr/co/vividnext/sodalive/utils/ImageBlurUtil.kt

@@ -0,0 +1,173 @@
+package kr.co.vividnext.sodalive.utils
+
+import java.awt.image.BufferedImage
+import java.awt.image.DataBufferInt
+import java.util.stream.IntStream
+import kotlin.math.exp
+import kotlin.math.max
+import kotlin.math.min
+import kotlin.math.roundToInt
+
+/**
+ * 가우시안 커널 기반 블러 유틸리티
+ * - 반경(radius)에 따라 커널 크기(2*radius+1) 생성
+ * - 시그마는 관례적으로 radius/3.0 적용
+ * - 수평/수직 분리 합성곱으로 품질과 성능 확보
+ */
+/**
+ * 고속 가우시안 블러 유틸
+ *
+ * - 원본 비율/해상도 그대로 두고 "큰 반경 블러"만 빠르게 적용하고 싶을 때 사용합니다.
+ * - 강한 익명화를 원하면(식별 불가 수준) 이 함수 대신
+ *   "다운스케일 → 큰 반경 블러 → 원본 해상도로 업스케일"을 조합하세요.
+ *   (예: ImageUtils.anonymizeStrongFast 처럼)
+ */
+object ImageBlurUtil {
+    /**
+     * 분리형(1D) 가우시안 블러(수평 → 수직 2패스), 배열 접근 기반 고속 구현.
+     *
+     * @param src      원본 이미지
+     * @param radius   가우시안 반경(>=1). 클수록 강하게 흐려짐. (권장 5~64)
+     * @param parallel true면 행/열 패스를 병렬 실행(ForkJoinPool). 멀티코어에서만 유효.
+     * @return 블러된 새 이미지 (TYPE_INT_ARGB)
+     */
+    fun blurFast(src: BufferedImage, radius: Int = 240, parallel: Boolean = true): BufferedImage {
+        require(radius > 0) { "radius must be > 0" }
+
+        // 1) 프리멀티 알파로 변환 (경계 품질↑)
+        val s = toPremultiplied(src) // TYPE_INT_ARGB_PRE
+        val w = s.width
+        val h = s.height
+
+        // 2) 중간/최종 버퍼(프리멀티 유지)
+        val tmp = BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB_PRE)
+        val dst = BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB_PRE)
+
+        val srcArr = (s.raster.dataBuffer as DataBufferInt).data
+        val tmpArr = (tmp.raster.dataBuffer as DataBufferInt).data
+        val dstArr = (dst.raster.dataBuffer as DataBufferInt).data
+
+        // 3) 1D 가우시안 커널(정규화)
+        //    sigma는 일반적으로 radius/3.0이 자연스러운 값
+        val sigma = radius / 3.0
+        val kernel = buildGaussian1D(radius, sigma)
+
+        // 4) 수평 패스 (y 라인별)
+        if (parallel) {
+            IntStream.range(0, h).parallel().forEach { y ->
+                convolveRow(srcArr, tmpArr, w, h, y, kernel, radius)
+            }
+        } else {
+            for (y in 0 until h) convolveRow(srcArr, tmpArr, w, h, y, kernel, radius)
+        }
+
+        // 5) 수직 패스 (x 컬럼별)
+        if (parallel) {
+            IntStream.range(0, w).parallel().forEach { x ->
+                convolveCol(tmpArr, dstArr, w, h, x, kernel, radius)
+            }
+        } else {
+            for (x in 0 until w) convolveCol(tmpArr, dstArr, w, h, x, kernel, radius)
+        }
+
+        // 6) 비프리멀티(일반 ARGB)로 변환해서 반환 (파일 저장/그리기 호환성↑)
+        return toNonPremultiplied(dst)
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────────
+    // 내부 구현
+    // ─────────────────────────────────────────────────────────────────────────────
+
+    // 수평 합성곱: 경계는 replicate(클램프)
+    private fun convolveRow(src: IntArray, dst: IntArray, w: Int, h: Int, y: Int, k: DoubleArray, r: Int) {
+        val base = y * w
+        for (x in 0 until w) {
+            var aAcc = 0.0
+            var rAcc = 0.0
+            var gAcc = 0.0
+            var bAcc = 0.0
+            var i = -r
+            while (i <= r) {
+                val xx = clamp(x + i, 0, w - 1)
+                val argb = src[base + xx]
+                val a = (argb ushr 24) and 0xFF
+                val rr = (argb ushr 16) and 0xFF
+                val gg = (argb ushr 8) and 0xFF
+                val bb = argb and 0xFF
+                val wgt = k[i + r]
+                aAcc += a * wgt; rAcc += rr * wgt; gAcc += gg * wgt; bAcc += bb * wgt
+                i++
+            }
+            val a = aAcc.roundToInt().coerceIn(0, 255)
+            val rr = rAcc.roundToInt().coerceIn(0, 255)
+            val gg = gAcc.roundToInt().coerceIn(0, 255)
+            val bb = bAcc.roundToInt().coerceIn(0, 255)
+            dst[base + x] = (a shl 24) or (rr shl 16) or (gg shl 8) or bb
+        }
+    }
+
+    // 수직 합성곱: 경계 replicate(클램프)
+    private fun convolveCol(src: IntArray, dst: IntArray, w: Int, h: Int, x: Int, k: DoubleArray, r: Int) {
+        var idx = x
+        for (y in 0 until h) {
+            var aAcc = 0.0
+            var rAcc = 0.0
+            var gAcc = 0.0
+            var bAcc = 0.0
+            var i = -r
+            while (i <= r) {
+                val yy = clamp(y + i, 0, h - 1)
+                val argb = src[yy * w + x]
+                val a = (argb ushr 24) and 0xFF
+                val rr = (argb ushr 16) and 0xFF
+                val gg = (argb ushr 8) and 0xFF
+                val bb = argb and 0xFF
+                val wgt = k[i + r]
+                aAcc += a * wgt; rAcc += rr * wgt; gAcc += gg * wgt; bAcc += bb * wgt
+                i++
+            }
+            val a = aAcc.roundToInt().coerceIn(0, 255)
+            val rr = rAcc.roundToInt().coerceIn(0, 255)
+            val gg = gAcc.roundToInt().coerceIn(0, 255)
+            val bb = bAcc.roundToInt().coerceIn(0, 255)
+            dst[idx] = (a shl 24) or (rr shl 16) or (gg shl 8) or bb
+            idx += w
+        }
+    }
+
+    // 1D 가우시안 커널 (정규화)
+    private fun buildGaussian1D(radius: Int, sigma: Double): DoubleArray {
+        val size = radius * 2 + 1
+        val kernel = DoubleArray(size)
+        val sigma2 = 2.0 * sigma * sigma
+        var sum = 0.0
+        for (i in -radius..radius) {
+            val v = exp(-(i * i) / sigma2)
+            kernel[i + radius] = v
+            sum += v
+        }
+        for (i in 0 until size) kernel[i] /= sum
+        return kernel
+    }
+
+    private fun clamp(v: Int, lo: Int, hi: Int): Int = max(lo, min(hi, v))
+
+    // 프리멀티/비프리멀티 변환(빠른 방법: Graphics로 그리기)
+    private fun toPremultiplied(src: BufferedImage): BufferedImage {
+        if (src.type == BufferedImage.TYPE_INT_ARGB_PRE) return src
+        val out = BufferedImage(src.width, src.height, BufferedImage.TYPE_INT_ARGB_PRE)
+        val g = out.createGraphics()
+        g.drawImage(src, 0, 0, null)
+        g.dispose()
+        return out
+    }
+
+    private fun toNonPremultiplied(src: BufferedImage): BufferedImage {
+        if (src.type == BufferedImage.TYPE_INT_ARGB) return src
+        val out = BufferedImage(src.width, src.height, BufferedImage.TYPE_INT_ARGB)
+        val g = out.createGraphics()
+        g.drawImage(src, 0, 0, null)
+        g.dispose()
+        return out
+    }
+}

src/main/resources/application.yml

@@ -1,5 +1,6 @@
 server:
     shutdown: graceful
+    env: ${SERVER_ENV}
 
 logging:
     level:
@@ -8,6 +9,10 @@ logging:
                 util:
                     EC2MetadataUtils: error
 
+weraser:
+    apiUrl: ${WERASER_API_URL}
+    apiKey: ${WERASER_API_KEY}
+
 bootpay:
     applicationId: ${BOOTPAY_APPLICATION_ID}
     privateKey: ${BOOTPAY_PRIVATE_KEY}