build.gradle.kts

@@ -28,7 +28,7 @@ repositories {
 
 dependencies {
     // https://mvnrepository.com/artifact/ch.qos.logback/logback-classic
-    implementation("ch.qos.logback:logback-classic:1.5.13")
+    implementation("ch.qos.logback:logback-classic:1.5.12")
 
     // https://mvnrepository.com/artifact/org.jetbrains.kotlinx/kotlinx-coroutines-core
     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0")

chatbot/build.gradle.kts

@@ -16,10 +16,10 @@ dependencies {
     }
 
     // https://mvnrepository.com/artifact/io.github.R2turnTrue/chzzk4j
-    implementation("io.github.R2turnTrue:chzzk4j:0.1.1")
+    implementation("io.github.R2turnTrue:chzzk4j:0.0.12")
 
     // https://mvnrepository.com/artifact/ch.qos.logback/logback-classic
-    implementation("ch.qos.logback:logback-classic:1.5.13")
+    implementation("ch.qos.logback:logback-classic:1.5.12")
 
     // https://mvnrepository.com/artifact/org.jetbrains.kotlinx/kotlinx-coroutines-core
     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0")

chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/chzzk/ChzzkHandler.kt

@@ -1,31 +1,25 @@
 package space.mori.chzzk_bot.chatbot.chzzk
 
-import com.google.gson.Gson
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.future.await
 import kotlinx.coroutines.launch
-import okhttp3.OkHttpClient
 import org.koin.java.KoinJavaComponent.inject
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
-import space.mori.chzzk_bot.chatbot.chzzk.Connector.client as ChzzkClient
+import space.mori.chzzk_bot.chatbot.chzzk.Connector.chzzk
 import space.mori.chzzk_bot.chatbot.chzzk.Connector.getChannel
 import space.mori.chzzk_bot.chatbot.discord.Discord
-import space.mori.chzzk_bot.chatbot.utils.refreshAccessToken
 import space.mori.chzzk_bot.common.events.*
 import space.mori.chzzk_bot.common.models.User
 import space.mori.chzzk_bot.common.services.LiveStatusService
 import space.mori.chzzk_bot.common.services.TimerConfigService
 import space.mori.chzzk_bot.common.services.UserService
 import space.mori.chzzk_bot.common.utils.*
-import xyz.r2turntrue.chzzk4j.ChzzkClient
+import xyz.r2turntrue.chzzk4j.chat.ChatEventListener
-import xyz.r2turntrue.chzzk4j.auth.ChzzkSimpleUserLoginAdapter
+import xyz.r2turntrue.chzzk4j.chat.ChatMessage
-import xyz.r2turntrue.chzzk4j.session.ChzzkSessionBuilder
+import xyz.r2turntrue.chzzk4j.chat.ChzzkChat
-import xyz.r2turntrue.chzzk4j.session.ChzzkSessionSubscriptionType
-import xyz.r2turntrue.chzzk4j.session.ChzzkUserSession
-import xyz.r2turntrue.chzzk4j.session.event.SessionChatMessageEvent
 import xyz.r2turntrue.chzzk4j.types.channel.ChzzkChannel
 import java.lang.Exception
 import java.net.SocketTimeoutException
@@ -43,17 +37,18 @@ object ChzzkHandler {
     }
 
     fun enable() {
+        botUid = chzzk.loggedUser.userId
         UserService.getAllUsers().map {
             if(!it.isDisabled)
                 try {
-                    Connector.getChannel(it.token)?.let { token -> addUser(token, it) }
+                    chzzk.getChannel(it.token)?.let { token -> addUser(token, it) }
                 } catch(e: Exception) {
                     logger.info("Exception: ${it.token}(${it.username}) not found. ${e.stackTraceToString()}")
                 }
         }
 
         handlers.forEach { handler ->
-            val streamInfo = getStreamInfo(handler.channel.channelId)
+            val streamInfo = getStreamInfo(handler.listener.channelId)
             if (streamInfo.content?.status == "OPEN") handler.isActive(true, streamInfo)
         }
 
@@ -204,8 +199,7 @@ class UserHandler(
     var streamStartTime: LocalDateTime?,
 ) {
     var messageHandler: MessageHandler
-    lateinit var client: ChzzkClient
+    var listener: ChzzkChat
-    lateinit var listener: ChzzkUserSession
 
     private val dispatcher: CoroutinesEventBus by inject(CoroutinesEventBus::class.java)
     private var _isActive: Boolean
@@ -215,30 +209,35 @@ class UserHandler(
         }
 
     init {
-        val user = UserService.getUser(channel.channelId)
+        listener = chzzk.chat(channel.channelId)
+            .withAutoReconnect(true)
+            .withChatListener(object : ChatEventListener {
+                override fun onConnect(chat: ChzzkChat, isReconnecting: Boolean) {
+                    logger.info("${channel.channelName} - ${channel.channelId} / reconnected: $isReconnecting")
+                }
 
-        if(user?.accessToken == null || user.refreshToken == null) {
+                override fun onError(ex: Exception) {
-            throw RuntimeException("AccessToken or RefreshToken is not valid.")
+                    logger.info("ChzzkChat error. ${channel.channelName} - ${channel.channelId}")
-        }
+                    logger.info(ex.stackTraceToString())
+                }
 
-        val tokens = ChzzkClient.refreshAccessToken(user.refreshToken!!)
+                override fun onChat(msg: ChatMessage) {
+                    if(!_isActive) return
+                    messageHandler.handle(msg, user)
+                }
 
-        client = Connector.getClient(tokens.first, tokens.second)
+                override fun onConnectionClosed(code: Int, reason: String?, remote: Boolean, tryingToReconnect: Boolean) {
-        listener = ChzzkSessionBuilder(client).buildUserSession()
+                    logger.info("ChzzkChat closed. ${channel.channelName} - ${channel.channelId}")
-
+                    logger.info("Reason: $reason / $tryingToReconnect")
-        UserService.setRefreshToken(user, tokens.first, tokens.second)
+                }
-
+            })
-        listener.createAndConnectAsync().join()
+            .build()
-
-        listener.on(SessionChatMessageEvent::class.java) {
-            messageHandler.handle(it.message, user)
-        }
         messageHandler = MessageHandler(this@UserHandler)
     }
 
+
     internal fun disable() {
-        listener.disconnectAsync().join()
+        listener.closeAsync()
-        _isActive = false
     }
 
     internal fun reloadCommand() {
@@ -260,7 +259,7 @@ class UserHandler(
                 reloadUser(UserService.getUser(user.id.value)!!)
 
                 logger.info("ChzzkChat connecting... ${channel.channelName} - ${channel.channelId}")
-                listener.subscribeAsync(ChzzkSessionSubscriptionType.CHAT)
+                listener.connectAsync().await()
 
                 streamStartTime = status.content?.openDate?.let { convertChzzkDateToLocalDateTime(it) }
 
@@ -286,7 +285,7 @@ class UserHandler(
                     delay(5000L)
                     try {
                         if(!user.isDisableStartupMsg)
-                            sendChat("${user.username} 님! 오늘도 열심히 방송하세요!")
+                            listener.sendChat("${user.username} 님! 오늘도 열심히 방송하세요!")
                         Discord.sendDiscord(user, status)
                     } catch(e: Exception) {
                         logger.info("Stream on logic has some error: ${e.stackTraceToString()}")
@@ -296,7 +295,7 @@ class UserHandler(
         } else {
             logger.info("${user.username} is offline.")
             streamStartTime = null
-            listener.disconnectAsync().join()
+            listener.closeAsync()
             _isActive = false
 
             CoroutineScope(Dispatchers.Default).launch {
@@ -320,8 +319,4 @@ class UserHandler(
             }
         }
     }
-
+}
-    internal fun sendChat(msg: String) {
-        client.sendChatToLoggedInChannel(msg)
-    }
-}

chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/chzzk/Connector.kt

@@ -2,10 +2,8 @@ package space.mori.chzzk_bot.chatbot.chzzk
 
 import io.github.cdimascio.dotenv.dotenv
 import org.slf4j.LoggerFactory
-import xyz.r2turntrue.chzzk4j.ChzzkClient
+import xyz.r2turntrue.chzzk4j.Chzzk
-import xyz.r2turntrue.chzzk4j.ChzzkClientBuilder
+import xyz.r2turntrue.chzzk4j.ChzzkBuilder
-import xyz.r2turntrue.chzzk4j.auth.ChzzkOauthLoginAdapter
-import xyz.r2turntrue.chzzk4j.auth.ChzzkSimpleUserLoginAdapter
 import xyz.r2turntrue.chzzk4j.types.channel.ChzzkChannel
 
 val dotenv = dotenv {
@@ -13,24 +11,14 @@ val dotenv = dotenv {
 }
 
 object Connector {
-    val client: ChzzkClient = ChzzkClientBuilder(dotenv["NAVER_CLIENT_ID"], dotenv["NAVER_CLIENT_SECRET"])
+    val chzzk: Chzzk = ChzzkBuilder()
+        .withAuthorization(dotenv["NID_AUT"], dotenv["NID_SES"])
         .build()
     private val logger = LoggerFactory.getLogger(this::class.java)
 
-    fun getChannel(channelId: String): ChzzkChannel? = client.fetchChannel(channelId)
+    fun getChannel(channelId: String): ChzzkChannel? = chzzk.getChannel(channelId)
 
     init {
-        logger.info("chzzk logged: ${client.isLoggedIn}")
+        logger.info("chzzk logged: ${chzzk.isLoggedIn} / ${chzzk.loggedUser?.nickname ?: "----"}")
-
-        client.loginAsync().join()
-    }
-
-    fun getClient(accessToken: String, refreshToken: String): ChzzkClient {
-        val adapter = ChzzkSimpleUserLoginAdapter(accessToken, refreshToken)
-        val client = ChzzkClientBuilder(dotenv["NAVER_CLIENT_ID"], dotenv["NAVER_CLIENT_SECRET"])
-            .withLoginAdapter(adapter)
-            .build()
-
-        return client
     }
 }

chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/chzzk/MessageHandler.kt

@@ -13,16 +13,15 @@ import space.mori.chzzk_bot.common.utils.getUptime
 import space.mori.chzzk_bot.common.utils.getYoutubeVideo
 import xyz.r2turntrue.chzzk4j.chat.ChatMessage
 import xyz.r2turntrue.chzzk4j.chat.ChzzkChat
-import xyz.r2turntrue.chzzk4j.session.ChzzkUserSession
-import xyz.r2turntrue.chzzk4j.session.message.SessionChatMessage
 import java.time.LocalDateTime
 import java.time.format.DateTimeFormatter
 import java.time.temporal.ChronoUnit
 
+
 class MessageHandler(
     private val handler: UserHandler
 ) {
-    private val commands = mutableMapOf<String, (msg: SessionChatMessage, user: User) -> Unit>()
+    private val commands = mutableMapOf<String, (msg: ChatMessage, user: User) -> Unit>()
 
     private val counterPattern = Regex("<counter:([^>]+)>")
     private val personalCounterPattern = Regex("<counter_personal:([^>]+)>")
@@ -72,90 +71,85 @@ class MessageHandler(
             this.commands.put(it.command.lowercase()) { msg, user ->
                 logger.debug("${channel.channelName} - ${it.command} - ${it.content}/${it.failContent}")
 
-                val result = replaceCounters(
+                val result = replaceCounters(Pair(it.content, it.failContent), user, msg, listener, msg.profile?.nickname ?: "")
-                    Pair(it.content, it.failContent),
+                listener.sendChat(result)
-                    user,
-                    msg,
-                    msg.profile?.nickname ?: ""
-                )
-                handler.sendChat(result)
             }
         }
     }
 
-    private fun commandListCommand(msg: SessionChatMessage, user: User) {
+    private fun commandListCommand(msg: ChatMessage, user: User) {
-        handler.sendChat("리스트는 여기입니다. https://nabot.mori.space/commands/${user.token}")
+        listener.sendChat("리스트는 여기입니다. https://nabot.mori.space/commands/${user.token}")
     }
 
-    private fun manageAddCommand(msg: SessionChatMessage, user: User) {
+    private fun manageAddCommand(msg: ChatMessage, user: User) {
-        if (msg.profile.badges.size == 0) {
+        if (msg.profile?.userRoleCode == "common_user") {
-            handler.sendChat("매니저만 명령어를 추가할 수 있습니다.")
+            listener.sendChat("매니저만 명령어를 추가할 수 있습니다.")
             return
         }
 
         val parts = msg.content.split(" ", limit = 3)
         if (parts.size < 3) {
-            handler.sendChat("명령어 추가 형식은 '!명령어추가 명령어 내용'입니다.")
+            listener.sendChat("명령어 추가 형식은 '!명령어추가 명령어 내용'입니다.")
             return
         }
         if (commands.containsKey(parts[1])) {
-            handler.sendChat("${parts[1]} 명령어는 이미 있는 명령어입니다.")
+            listener.sendChat("${parts[1]} 명령어는 이미 있는 명령어입니다.")
             return
         }
         val command = parts[1]
         val content = parts[2]
         CommandService.saveCommand(user, command, content, "")
-        handler.sendChat("명령어 '$command' 추가되었습니다.")
+        listener.sendChat("명령어 '$command' 추가되었습니다.")
     }
 
-    private fun manageUpdateCommand(msg: SessionChatMessage, user: User) {
+    private fun manageUpdateCommand(msg: ChatMessage, user: User) {
-        if (msg.profile.badges.size == 0) {
+        if (msg.profile?.userRoleCode == "common_user") {
-            handler.sendChat("매니저만 명령어를 추가할 수 있습니다.")
+            listener.sendChat("매니저만 명령어를 추가할 수 있습니다.")
             return
         }
 
         val parts = msg.content.split(" ", limit = 3)
         if (parts.size < 3) {
-            handler.sendChat("명령어 수정 형식은 '!명령어수정 명령어 내용'입니다.")
+            listener.sendChat("명령어 수정 형식은 '!명령어수정 명령어 내용'입니다.")
             return
         }
         if (!commands.containsKey(parts[1])) {
-            handler.sendChat("${parts[1]} 명령어는 없는 명령어입니다.")
+            listener.sendChat("${parts[1]} 명령어는 없는 명령어입니다.")
             return
         }
         val command = parts[1]
         val content = parts[2]
         CommandService.updateCommand(user, command, content, "")
-        handler.sendChat("명령어 '$command' 수정되었습니다.")
+        listener.sendChat("명령어 '$command' 수정되었습니다.")
         ChzzkHandler.reloadCommand(channel)
     }
 
-    private fun manageRemoveCommand(msg: SessionChatMessage, user: User) {
+    private fun manageRemoveCommand(msg: ChatMessage, user: User) {
-        if (msg.profile.badges.size == 0) {
+        if (msg.profile?.userRoleCode == "common_user") {
-            handler.sendChat("매니저만 명령어를 삭제할 수 있습니다.")
+            listener.sendChat("매니저만 명령어를 삭제할 수 있습니다.")
             return
         }
 
         val parts = msg.content.split(" ", limit = 2)
         if (parts.size < 2) {
-            handler.sendChat("명령어 삭제 형식은 '!명령어삭제 명령어'입니다.")
+            listener.sendChat("명령어 삭제 형식은 '!명령어삭제 명령어'입니다.")
             return
         }
         val command = parts[1]
         CommandService.removeCommand(user, command)
-        handler.sendChat("명령어 '$command' 삭제되었습니다.")
+        listener.sendChat("명령어 '$command' 삭제되었습니다.")
         ChzzkHandler.reloadCommand(channel)
     }
 
-    private fun timerCommand(msg: SessionChatMessage, user: User) {
+    private fun timerCommand(msg: ChatMessage, user: User) {
-        if (msg.profile.badges.size == 0) {
+        if (msg.profile?.userRoleCode == "common_user") {
-            handler.sendChat("매니저만 이 명령어를 사용할 수 있습니다.")
+            listener.sendChat("매니저만 이 명령어를 사용할 수 있습니다.")
             return
         }
 
         val parts = msg.content.split(" ", limit = 3)
         if (parts.size < 2) {
-            handler.sendChat("타이머 명령어 형식을 잘 찾아봐주세요!")
+            listener.sendChat("타이머 명령어 형식을 잘 찾아봐주세요!")
             return
         }
 
@@ -184,13 +178,13 @@ class MessageHandler(
                 when (parts[2]) {
                     "업타임" -> {
                         TimerConfigService.saveOrUpdateConfig(user, TimerType.UPTIME)
-                        handler.sendChat("기본 타이머 설정이 업타임으로 바뀌었습니다.")
+                        listener.sendChat("기본 타이머 설정이 업타임으로 바뀌었습니다.")
                     }
                     "삭제" -> {
                         TimerConfigService.saveOrUpdateConfig(user, TimerType.REMOVE)
-                        handler.sendChat("기본 타이머 설정이 삭제로 바뀌었습니다.")
+                        listener.sendChat("기본 타이머 설정이 삭제로 바뀌었습니다.")
                     }
-                    else -> handler.sendChat("!타이머 설정 (업타임/삭제) 형식으로 써주세요!")
+                    else -> listener.sendChat("!타이머 설정 (업타임/삭제) 형식으로 써주세요!")
                 }
             }
             else -> {
@@ -204,9 +198,9 @@ class MessageHandler(
                         dispatcher.post(TimerEvent(user.token, TimerType.TIMER, timestamp.toString()))
                     }
                 } catch (e: NumberFormatException) {
-                    handler.sendChat("!타이머/숫자 형식으로 적어주세요! 단위: 분")
+                    listener.sendChat("!타이머/숫자 형식으로 적어주세요! 단위: 분")
                 } catch (e: Exception) {
-                    handler.sendChat("타이머 설정 중 오류가 발생했습니다.")
+                    listener.sendChat("타이머 설정 중 오류가 발생했습니다.")
                     logger.error("Error processing timer command: ${e.message}", e)
                 }
             }
@@ -214,21 +208,21 @@ class MessageHandler(
     }
 
     // songs
-    private fun songAddCommand(msg: SessionChatMessage, user: User) {
+    private fun songAddCommand(msg: ChatMessage, user: User) {
         if(SongConfigService.getConfig(user).disabled) {
             return
         }
 
         val parts = msg.content.split(" ", limit = 2)
         if (parts.size < 2) {
-            handler.sendChat("유튜브 URL을 입력해주세요!")
+            listener.sendChat("유튜브 URL을 입력해주세요!")
             return
         }
 
         val config = SongConfigService.getConfig(user)
 
-        if(config.streamerOnly && msg.profile.badges.size == 0) {
+        if(config.streamerOnly && msg.profile?.userRoleCode == "common_user") {
-            handler.sendChat("매니저만 이 명령어를 사용할 수 있습니다.")
+            listener.sendChat("매니저만 이 명령어를 사용할 수 있습니다.")
             return
         }
 
@@ -236,34 +230,34 @@ class MessageHandler(
         val songs = SongListService.getSong(user)
 
         if(songs.size >= config.queueLimit) {
-            handler.sendChat("더이상 노래를 신청할 수 없습니다. 잠시 뒤 다시 시도해주세요!")
+            listener.sendChat("더이상 노래를 신청할 수 없습니다. 잠시 뒤 다시 시도해주세요!")
             return
         }
-        if(songs.filter { it.uid == msg.senderChannelId }.size  >= config.personalLimit) {
+        if(songs.filter { it.uid == msg.userId }.size  >= config.personalLimit) {
-            handler.sendChat("더이상 노래를 신청할 수 없습니다. 잠시 뒤 다시 시도해주세요!")
+            listener.sendChat("더이상 노래를 신청할 수 없습니다. 잠시 뒤 다시 시도해주세요!")
             return
         }
 
         try {
             val video = getYoutubeVideo(url)
             if (video == null) {
-                handler.sendChat("유튜브에서 찾을 수 없어요!")
+                listener.sendChat("유튜브에서 찾을 수 없어요!")
                 return
             }
 
             if (songs.any { it.url == video.url }) {
-                handler.sendChat("같은 노래가 이미 신청되어 있습니다.")
+                listener.sendChat("같은 노래가 이미 신청되어 있습니다.")
                 return
             }
 
             if (video.length > 600) {
-                handler.sendChat("10분이 넘는 노래는 신청할 수 없습니다.")
+                listener.sendChat("10분이 넘는 노래는 신청할 수 없습니다.")
                 return
             }
 
             SongListService.saveSong(
                 user,
-                msg.senderChannelId,
+                msg.userId,
                 video.url,
                 video.name,
                 video.author,
@@ -275,31 +269,31 @@ class MessageHandler(
                     SongEvent(
                         user.token,
                         SongType.ADD,
-                        msg.senderChannelId,
+                        msg.userId,
                         null,
                         video,
                     )
                 )
             }
 
-            handler.sendChat("노래가 추가되었습니다. ${video.name} - ${video.author}")
+            listener.sendChat("노래가 추가되었습니다. ${video.name} - ${video.author}")
         } catch(e: Exception) {
-            handler.sendChat("유튜브 영상 주소로 다시 신청해주세요!")
+            listener.sendChat("유튜브 영상 주소로 다시 신청해주세요!")
             logger.info(e.stackTraceToString())
         }
     }
 
-    private fun songListCommand(msg: SessionChatMessage, user: User) {
+    private fun songListCommand(msg: ChatMessage, user: User) {
         if(SongConfigService.getConfig(user).disabled) {
             return
         }
         
-        handler.sendChat("리스트는 여기입니다. https://nabot.mori.space/songs/${user.token}")
+        listener.sendChat("리스트는 여기입니다. https://nabot.mori.space/songs/${user.token}")
     }
 
-    private fun songStartCommand(msg: SessionChatMessage, user: User) {
+    private fun songStartCommand(msg: ChatMessage, user: User) {
-        if (msg.profile?.badges?.size == 0) {
+        if (msg.profile?.userRoleCode == "common_user") {
-            handler.sendChat("매니저만 이 명령어를 사용할 수 있습니다.")
+            listener.sendChat("매니저만 이 명령어를 사용할 수 있습니다.")
             return
         }
 
@@ -312,28 +306,28 @@ class MessageHandler(
                 }
             }
         } else {
-            handler.sendChat("나봇 홈페이지의 노래목록 페이지를 이용해주세요! 디스코드 연동을 하시면 DM으로 바로 전송됩니다.")
+            listener.sendChat("나봇 홈페이지의 노래목록 페이지를 이용해주세요! 디스코드 연동을 하시면 DM으로 바로 전송됩니다.")
         }
     }
 
-    internal fun handle(msg: SessionChatMessage, user: User) {
+    internal fun handle(msg: ChatMessage, user: User) {
-        if(msg.senderChannelId == ChzzkHandler.botUid) return
+        if(msg.userId == ChzzkHandler.botUid) return
 
         val commandKey = msg.content.split(' ')[0]
         commands[commandKey.lowercase()]?.let { it(msg, user) }
     }
 
-    private fun replaceCounters(chat: Pair<String, String>, user: User, msg: SessionChatMessage, userName: String): String {
+    private fun replaceCounters(chat: Pair<String, String>, user: User, msg: ChatMessage, listener: ChzzkChat, userName: String): String {
         var result = chat.first
         var isFail = false
 
         // Replace dailyCounterPattern
         result = dailyCounterPattern.replace(result) { matchResult ->
             val name = matchResult.groupValues[1]
-            val dailyCounter = CounterService.getDailyCounterValue(name, msg.senderChannelId, user)
+            val dailyCounter = CounterService.getDailyCounterValue(name, msg.userId, user)
 
             if (dailyCounter.second) {
-                CounterService.updateDailyCounterValue(name, msg.senderChannelId, 1, user).first.toString()
+                CounterService.updateDailyCounterValue(name, msg.userId, 1, user).first.toString()
             } else {
                 isFail = true
                 dailyCounter.first.toString()
@@ -345,7 +339,7 @@ class MessageHandler(
             result = chat.second
             result = dailyCounterPattern.replace(result) { matchResult ->
                 val name = matchResult.groupValues[1]
-                val dailyCounter = CounterService.getDailyCounterValue(name, msg.senderChannelId, user)
+                val dailyCounter = CounterService.getDailyCounterValue(name, msg.userId, user)
                 dailyCounter.first.toString()
             }
         }
@@ -353,7 +347,7 @@ class MessageHandler(
         // Replace followPattern
         result = followPattern.replace(result) { _ ->
             try {
-                val followingDate = getFollowDate(channel.channelId, msg.senderChannelId)
+                val followingDate = getFollowDate(listener.chatId, msg.userId)
                     .content?.streamingProperty?.following?.followDate
 
                 val period = followingDate?.let {
@@ -389,7 +383,7 @@ class MessageHandler(
         // Replace personalCounterPattern
         result = personalCounterPattern.replace(result) { matchResult ->
             val name = matchResult.groupValues[1]
-            CounterService.updatePersonalCounterValue(name, msg.senderChannelId, 1, user).toString()
+            CounterService.updatePersonalCounterValue(name, msg.userId, 1, user).toString()
         }
 
         // Replace namePattern
@@ -397,4 +391,5 @@ class MessageHandler(
 
         return result
     }
-}
+
+}

chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/utils/accessTokenRefresh.kt

@@ -1,55 +0,0 @@
-package space.mori.chzzk_bot.chatbot.utils
-
-import com.google.gson.Gson
-import okhttp3.OkHttpClient
-import okhttp3.Request
-import okhttp3.RequestBody.Companion.toRequestBody
-import space.mori.chzzk_bot.common.utils.client
-import xyz.r2turntrue.chzzk4j.ChzzkClient
-import java.io.IOException
-
-val client = OkHttpClient.Builder()
-    .addNetworkInterceptor { chain ->
-        chain.proceed(
-            chain.request()
-                .newBuilder()
-                .header("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36")
-                .build()
-        )
-    }
-    .build()
-val gson = Gson()
-
-data class RefreshTokenResponse(
-    val accessToken: String,
-    val refreshToken: String,
-    val expiresIn: Int,
-    val tokenType: String = "Bearer",
-    val scope: String
-)
-
-fun ChzzkClient.refreshAccessToken(refreshToken: String): Pair<String, String> {
-    val url = "https://openapi.chzzk.naver.com/auth/v1/token"
-    val request = Request.Builder()
-        .url(url)
-        .header("Content-Type", "application/json")
-        .post(gson.toJson(mapOf(
-            "grantType" to "refresh_token",
-            "refreshToken" to refreshToken,
-            "clientId" to this.apiClientId,
-            "clientSecret" to this.apiSecret
-        )).toRequestBody())
-        .build()
-
-    client.newCall(request).execute().use { response ->
-        try {
-            if(!response.isSuccessful) throw IOException("Unexpected code ${response.code}")
-            val body = response.body?.string()
-            val data = gson.fromJson(body, RefreshTokenResponse::class.java)
-
-            return Pair(data.accessToken, data.refreshToken)
-        } catch(e: Exception) {
-            throw e
-        }
-    }
-}

common/build.gradle.kts

@@ -23,7 +23,7 @@ dependencies {
     api("com.zaxxer:HikariCP:6.1.0")
 
     // https://mvnrepository.com/artifact/ch.qos.logback/logback-classic
-    implementation("ch.qos.logback:logback-classic:1.5.13")
+    implementation("ch.qos.logback:logback-classic:1.5.12")
 
     // https://mvnrepository.com/artifact/org.mariadb.jdbc/mariadb-java-client
     implementation("org.mariadb.jdbc:mariadb-java-client:3.5.0")

webserver/build.gradle.kts

@@ -10,7 +10,7 @@ repositories {
     mavenCentral()
 }
 
-val ktorVersion = "3.1.3"
+val ktorVersion = "3.0.1"
 
 dependencies {
     implementation("io.ktor:ktor-server-core:$ktorVersion")