[hotfix] ChzzkClient.refreshAccessToken added.

# Conflicts:
#	chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/chzzk/ChzzkHandler.kt
#	chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/utils/accessTokenRefresh.kt

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

@@ -1,13 +1,14 @@
 package space.mori.chzzk_bot.chatbot.chzzk
 
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.DelicateCoroutinesApi
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 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.getChannel
 import space.mori.chzzk_bot.chatbot.discord.Discord
 import space.mori.chzzk_bot.chatbot.utils.refreshAccessToken
@@ -23,10 +24,11 @@ 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 xyz.r2turntrue.chzzk4j.types.channel.live.ChzzkLiveStatus
+import xyz.r2turntrue.chzzk4j.types.channel.live.ChzzkLiveDetail
 import java.lang.Exception
 import java.net.SocketTimeoutException
 import java.time.LocalDateTime
+import java.nio.charset.Charset
 
 object ChzzkHandler {
     private val handlers = mutableListOf<UserHandler>()
@@ -36,10 +38,11 @@ object ChzzkHandler {
     private val dispatcher: CoroutinesEventBus by inject(CoroutinesEventBus::class.java)
 
     fun addUser(chzzkChannel: ChzzkChannel, user: User) {
-        handlers.add(UserHandler(chzzkChannel, logger, user, streamStartTime = null))
+        handlers.add(UserHandler(chzzkChannel, logger, user, streamStartTime = LocalDateTime.now()))
     }
 
     fun enable() {
+        botUid = Connector.client.fetchLoggedUser().userId
         UserService.getAllUsers().map {
             if(!it.isDisabled)
                 try {
@@ -194,6 +197,7 @@ object ChzzkHandler {
     }
 }
 
+@OptIn(DelicateCoroutinesApi::class)
 class UserHandler(
     val channel: ChzzkChannel,
     val logger: Logger,
@@ -203,6 +207,7 @@ class UserHandler(
     var messageHandler: MessageHandler
     var client: ChzzkClient
     var listener: ChzzkUserSession
+    var chatChannelId: String?
 
     private val dispatcher: CoroutinesEventBus by inject(CoroutinesEventBus::class.java)
     private var _isActive: Boolean
@@ -217,20 +222,44 @@ class UserHandler(
         if(user?.accessToken == null || user.refreshToken == null) {
             throw RuntimeException("AccessToken or RefreshToken is not valid.")
         }
-
+        try {
-        val tokens = ChzzkClient.refreshAccessToken(user.refreshToken!!)
+            val tokens = Connector.client.refreshAccessToken(user.refreshToken!!)
-
             client = Connector.getClient(tokens.first, tokens.second)
-        listener = ChzzkSessionBuilder(client).buildUserSession()
-
             UserService.setRefreshToken(user, tokens.first, tokens.second)
+            chatChannelId = getChzzkChannelId(channel.channelId)
 
+            client.loginAsync().join()
+            listener = ChzzkSessionBuilder(client).buildUserSession()
             listener.createAndConnectAsync().join()
+            messageHandler = MessageHandler(this@UserHandler)
 
             listener.on(SessionChatMessageEvent::class.java) {
                 messageHandler.handle(it.message, user)
             }
-        messageHandler = MessageHandler(this@UserHandler)
+
+            GlobalScope.launch {
+                val timer = TimerConfigService.getConfig(user)
+                if (timer?.option == TimerType.UPTIME.value)
+                    dispatcher.post(
+                        TimerEvent(
+                            channel.channelId,
+                            TimerType.UPTIME,
+                            getUptime(streamStartTime!!)
+                        )
+                    )
+                else dispatcher.post(
+                    TimerEvent(
+                        channel.channelId,
+                        TimerType.entries.firstOrNull { it.value == timer?.option } ?: TimerType.REMOVE,
+                        null
+                    )
+                )
+            }
+            
+        } catch(e: Exception) {
+            logger.error("Exception(${user.username}): ${e.stackTraceToString()}")
+            throw RuntimeException("Exception: ${e.stackTraceToString()}")
+        }
     }
 
     internal fun disable() {
@@ -249,7 +278,7 @@ class UserHandler(
     internal val isActive: Boolean
         get() = _isActive
 
-    internal fun isActive(value: Boolean, status: ChzzkLiveStatus) {
+    internal fun isActive(value: Boolean, status: ChzzkLiveDetail) {
         if(value) {
             CoroutineScope(Dispatchers.Default).launch {
                 logger.info("${user.username} is live.")
@@ -257,7 +286,7 @@ class UserHandler(
                 reloadUser(UserService.getUser(user.id.value)!!)
 
                 logger.info("ChzzkChat connecting... ${channel.channelName} - ${channel.channelId}")
-                listener.subscribeAsync(ChzzkSessionSubscriptionType.CHAT)
+                listener.subscribeAsync(ChzzkSessionSubscriptionType.CHAT).join()
 
                 streamStartTime = LocalDateTime.now()
 
@@ -318,7 +347,21 @@ class UserHandler(
         }
     }
 
+    private fun String.limitUtf8Length(maxBytes: Int): String {
+        val bytes = this.toByteArray(Charset.forName("UTF-8"))
+        if (bytes.size <= maxBytes) return this
+        var truncatedString = this
+        while (truncatedString.toByteArray(Charset.forName("UTF-8")).size > maxBytes) {
+            truncatedString = truncatedString.substring(0, truncatedString.length - 1)
+        }
+        return truncatedString
+    }
+
+    @OptIn(DelicateCoroutinesApi::class)
     internal fun sendChat(msg: String) {
-        client.sendChatToLoggedInChannel(msg)
+        GlobalScope.launch {
+            delay(100L)
+            client.sendChatToLoggedInChannel(msg.limitUtf8Length(100))
+        }
     }
 }

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

@@ -14,7 +14,7 @@ import xyz.r2turntrue.chzzk4j.ChzzkClientBuilder
 import xyz.r2turntrue.chzzk4j.auth.ChzzkLegacyLoginAdapter
 import xyz.r2turntrue.chzzk4j.auth.ChzzkSimpleUserLoginAdapter
 import xyz.r2turntrue.chzzk4j.types.channel.ChzzkChannel
-import xyz.r2turntrue.chzzk4j.types.channel.live.ChzzkLiveStatus
+import xyz.r2turntrue.chzzk4j.types.channel.live.ChzzkLiveDetail
 import kotlin.getValue
 
 val dotenv = dotenv {
@@ -31,7 +31,7 @@ object Connector {
     private val dispatcher: CoroutinesEventBus by inject(CoroutinesEventBus::class.java)
 
     fun getChannel(channelId: String): ChzzkChannel? = client.fetchChannel(channelId)
-    fun getLive(channelId: String): ChzzkLiveStatus? = client.fetchLiveStatus(channelId)
+    fun getLive(channelId: String): ChzzkLiveDetail? = client.fetchLiveDetail(channelId)
 
     init {
         logger.info("chzzk logged: ${client.isLoggedIn}")

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

@@ -88,7 +88,7 @@ class MessageHandler(
     }
 
     private fun manageAddCommand(msg: SessionChatMessage, user: User) {
-        if (msg.profile.badges.size == 0) {
+        if (msg.profile.badges.none { it.imageUrl.contains("manager") }) {
             handler.sendChat("매니저만 명령어를 추가할 수 있습니다.")
             return
         }
@@ -109,7 +109,7 @@ class MessageHandler(
     }
 
     private fun manageUpdateCommand(msg: SessionChatMessage, user: User) {
-        if (msg.profile.badges.size == 0) {
+        if (msg.profile.badges.none { it.imageUrl.contains("manager") }) {
             handler.sendChat("매니저만 명령어를 추가할 수 있습니다.")
             return
         }
@@ -131,7 +131,7 @@ class MessageHandler(
     }
 
     private fun manageRemoveCommand(msg: SessionChatMessage, user: User) {
-        if (msg.profile.badges.size == 0) {
+        if (msg.profile.badges.none { it.imageUrl.contains("manager") }) {
             handler.sendChat("매니저만 명령어를 삭제할 수 있습니다.")
             return
         }
@@ -148,7 +148,7 @@ class MessageHandler(
     }
 
     private fun timerCommand(msg: SessionChatMessage, user: User) {
-        if (msg.profile.badges.size == 0) {
+        if (msg.profile.badges.none { it.imageUrl.contains("manager") }) {
             handler.sendChat("매니저만 이 명령어를 사용할 수 있습니다.")
             return
         }
@@ -227,7 +227,7 @@ class MessageHandler(
 
         val config = SongConfigService.getConfig(user)
 
-        if(config.streamerOnly && msg.profile.badges.size == 0) {
+        if(config.streamerOnly && msg.profile.badges.none { it.imageUrl.contains("manager") }) {
             handler.sendChat("매니저만 이 명령어를 사용할 수 있습니다.")
             return
         }
@@ -298,7 +298,7 @@ class MessageHandler(
     }
 
     private fun songStartCommand(msg: SessionChatMessage, user: User) {
-        if (msg.profile?.badges?.size == 0) {
+        if (msg.profile.badges.none { it.imageUrl.contains("manager") }) {
             handler.sendChat("매니저만 이 명령어를 사용할 수 있습니다.")
             return
         }
@@ -353,15 +353,15 @@ class MessageHandler(
         // Replace followPattern
         result = followPattern.replace(result) { _ ->
             try {
-                val followingDate = getFollowDate(channel.channelId, msg.senderChannelId)
+                val followingDate = handler.chatChannelId?.let { getFollowDate(it, msg.senderChannelId) }
-                    .content?.streamingProperty?.following?.followDate
+                    ?.content?.streamingProperty?.following?.followDate ?: LocalDateTime.now().minusDays(1).toString()
 
-                val period = followingDate?.let {
+                val period = followingDate.let {
                     val formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")
                     val pastDate = LocalDateTime.parse(it, formatter)
                     val today = LocalDateTime.now()
                     ChronoUnit.DAYS.between(pastDate, today)
-                } ?: 0
+                } + 1
 
                 period.toString()
             } catch (e: Exception) {

chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/discord/Discord.kt

@@ -14,7 +14,8 @@ import net.dv8tion.jda.api.utils.messages.MessageCreateBuilder
 import org.slf4j.LoggerFactory
 import space.mori.chzzk_bot.chatbot.discord.commands.*
 import space.mori.chzzk_bot.common.models.User
-import xyz.r2turntrue.chzzk4j.types.channel.live.ChzzkLiveStatus
+import xyz.r2turntrue.chzzk4j.types.channel.live.ChzzkLiveDetail
+import xyz.r2turntrue.chzzk4j.types.channel.live.Resolution
 import java.time.Instant
 import kotlin.jvm.optionals.getOrNull
 
@@ -33,7 +34,7 @@ class Discord: ListenerAdapter() {
             return bot.getGuildById(guildId)?.getTextChannelById(channelId)
         }
 
-        fun sendDiscord(user: User, status: ChzzkLiveStatus) {
+        fun sendDiscord(user: User, status: ChzzkLiveDetail) {
             if(user.liveAlertMessage != null && user.liveAlertGuild != null && user.liveAlertChannel != null) {
                 val channel = getChannel(user.liveAlertGuild ?: 0, user.liveAlertChannel ?: 0)
                     ?: throw RuntimeException("${user.liveAlertChannel} is not valid.")
@@ -43,9 +44,16 @@ class Discord: ListenerAdapter() {
                 embed.setDescription("${user.username} 님이 방송을 시작했습니다.")
                 embed.setTimestamp(Instant.now())
                 embed.setAuthor(user.username, "https://chzzk.naver.com/live/${user.token}")
-                embed.addField("카테고리", status.categoryType.getOrNull() ?: "Unknown", true)
+                embed.addField("카테고리", status.liveCategoryValue, true)
-                embed.addField("태그", status.tags.joinToString { "," }, true)
+                embed.addField("태그", status.tags.joinToString(", ") { it.trim() }, true)
-                // embed.setImage(status.)
+                status.defaultThumbnailImageUrl.getOrNull()?.let { embed.setImage(it) }
+                    ?: Resolution.entries.reversed().forEach {
+                        val thumbnail = status.getLiveImageUrl(it)
+                        if (thumbnail != null) {
+                            embed.setImage(thumbnail)
+                            return@forEach
+                        }
+                    }
 
                 channel.sendMessage(
                     MessageCreateBuilder()

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

@@ -29,7 +29,7 @@ data class RefreshTokenResponse(
 )
 
 fun ChzzkClient.refreshAccessToken(refreshToken: String): Pair<String, String> {
-    val url = "https://openapi.chzzk.naver.com/auth/v1/token"
+    val url = "https://chzzk.naver.com/auth/v1/token"
     val request = Request.Builder()
         .url(url)
         .header("Content-Type", "application/json")

common/src/main/kotlin/space/mori/chzzk_bot/common/utils/ChzzkApis.kt

@@ -52,6 +52,20 @@ data class NicknameColor(
     val colorCode: String = ""
 )
 
+data class LiveStatus(
+    val liveTitle: String,
+    val status: String,
+    val concurrentUserCount: Int,
+    val accumulateCount: Int,
+    val paidPromotion: Boolean,
+    val adult: Boolean,
+    val krOnlyViewing: Boolean,
+    val openDate: String,
+    val closeDate: String?,
+    val clipActive: Boolean,
+    val chatChannelId: String
+)
+
 // OkHttpClient에 Interceptor 추가
 val client = OkHttpClient.Builder()
     .addNetworkInterceptor { chain ->
@@ -84,3 +98,24 @@ fun getFollowDate(chatID: String, userId: String) : IData<IFollowContent?> {
         }
     }
 }
+
+fun getChzzkChannelId(channelId: String): String? {
+    val url = "https://api.chzzk.naver.com/polling/v3/channels/$channelId/live-status?includePlayerRecommendContent=false"
+    val request = Request.Builder()
+        .url(url)
+        .header("Content-Type", "application/json")
+        .get()
+        .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, object: TypeToken<IData<LiveStatus?>>() {})
+
+            return data.content?.chatChannelId
+        } catch(e: Exception) {
+            throw e
+        }
+    }
+}

webserver/src/main/kotlin/space/mori/chzzk_bot/webserver/Main.kt

@@ -22,12 +22,16 @@ import io.ktor.server.websocket.*
 import kotlinx.coroutines.delay
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.json.Json
+import org.koin.java.KoinJavaComponent.inject
+import space.mori.chzzk_bot.common.events.CoroutinesEventBus
+import space.mori.chzzk_bot.common.events.UserRegisterEvent
 import space.mori.chzzk_bot.common.services.UserService
 import space.mori.chzzk_bot.webserver.routes.*
 import space.mori.chzzk_bot.webserver.utils.DiscordRatelimits
 import java.math.BigInteger
 import java.security.SecureRandom
 import java.time.Duration
+import kotlin.getValue
 import kotlin.time.toKotlinDuration
 
 val dotenv = dotenv {
@@ -81,6 +85,8 @@ val server = embeddedServer(Netty, port = 8080, ) {
         }
     }
     routing {
+        val dispatcher: CoroutinesEventBus by inject(CoroutinesEventBus::class.java)
+
         route("/auth") {
             // discord login
             authenticate("auth-oauth-discord") {
@@ -191,7 +197,12 @@ val server = embeddedServer(Netty, port = 8080, ) {
                     val userInfo = getChzzkUser(tokenResponse.content.accessToken)
 
                     if(userInfo.content != null) {
-                        val user = UserService.getUser(userInfo.content.channelId)
+                        var user = UserService.getUser(userInfo.content.channelId)
+
+                        if(user == null) {
+                            user = UserService.saveUser(userInfo.content.channelName , userInfo.content.channelId)
+                        }
+
                         call.sessions.set(
                             UserSession(
                                 session.state,
@@ -199,7 +210,13 @@ val server = embeddedServer(Netty, port = 8080, ) {
                                 listOf()
                             )
                         )
-                        user?.let { UserService.setRefreshToken(it, tokenResponse.content.accessToken, tokenResponse.content.refreshToken ?: "") }
+                        UserService.setRefreshToken(user,
+                            tokenResponse.content.accessToken,
+                            tokenResponse.content.refreshToken ?: ""
+                        )
+
+                        dispatcher.post(UserRegisterEvent(user.token))
+
                         call.respondRedirect(getFrontendURL(""))
                     }
                 } catch (e: Exception) {

webserver/src/main/kotlin/space/mori/chzzk_bot/webserver/routes/ApiRoutes.kt

@@ -40,12 +40,16 @@ fun Routing.apiRoutes() {
     val dispatcher: CoroutinesEventBus by inject(CoroutinesEventBus::class.java)
 
     suspend fun getChzzkUserWithId(uid: String): ChzzkUserReceiveEvent? {
-        val completableDeferred = CompletableDeferred< ChzzkUserReceiveEvent>()
+        val completableDeferred = CompletableDeferred<ChzzkUserReceiveEvent>()
+        dispatcher.subscribe(ChzzkUserReceiveEvent::class) { event ->
+            if (event.uid == uid) {
+                completableDeferred.complete(event)
+            }
+        }
         val user = withTimeoutOrNull(5000) {
             dispatcher.post(ChzzkUserFindEvent(uid))
             completableDeferred.await()
         }
-
         return user
     }
 
@@ -122,7 +126,7 @@ fun Routing.apiRoutes() {
                 user.subordinates.toList()
             }
             returnUsers.addAll(subordinates.map {
-                val subStatus = getChzzkUserWithId(user.token)
+                val subStatus = getChzzkUserWithId(it.token)
                 return@map if (subStatus == null) {
                     null
                 } else {

webserver/src/main/kotlin/space/mori/chzzk_bot/webserver/routes/WSSongRoutes.kt

@@ -37,9 +37,10 @@ fun Routing.wsSongRoutes() {
     fun addSession(uid: String, session: WebSocketServerSession) {
         sessions.computeIfAbsent(uid) { ConcurrentLinkedQueue() }.add(session)
     }
+
     fun removeSession(uid: String, session: WebSocketServerSession) {
         sessions[uid]?.remove(session)
-        if(sessions[uid]?.isEmpty() == true) {
+        if (sessions[uid]?.isEmpty() == true) {
             sessions.remove(uid)
         }
     }
@@ -88,30 +89,50 @@ fun Routing.wsSongRoutes() {
     }
 
     webSocket("/song/{uid}") {
+        logger.info("WebSocket connection attempt received")
         val uid = call.parameters["uid"]
         val user = uid?.let { UserService.getUser(it) }
         if (uid == null || user == null) {
+            logger.warn("Invalid UID: $uid")
             close(CloseReason(CloseReason.Codes.CANNOT_ACCEPT, "Invalid UID"))
             return@webSocket
         }
+        try {
             addSession(uid, this)
-        if(status[uid] == SongType.STREAM_OFF) {
+            logger.info("WebSocket connection established for user: $uid")
+
+            // Start heartbeat
+            val heartbeatJob = songScope.launch {
+                while (true) {
+                    try {
+                        send(Frame.Ping(ByteArray(0)))
+                        delay(30000) // 30 seconds
+                    } catch (e: Exception) {
+                        logger.error("Heartbeat failed for user $uid", e)
+                        break
+                    }
+                }
+            }
+
+            if (status[uid] == SongType.STREAM_OFF) {
                 songScope.launch {
-                sendSerialized(SongResponse(
+                    sendSerialized(
+                        SongResponse(
                             SongType.STREAM_OFF.value,
                             uid,
                             null,
                             null,
                             null,
-                ))
+                        )
+                    )
                 }
             }
             try {
                 for (frame in incoming) {
-                when(frame) {
+                    when (frame) {
                         is Frame.Text -> {
                             val text = frame.readText().trim()
-                        if(text == "ping") {
+                            if (text == "ping") {
                                 send("pong")
                             } else {
                                 val data = Json.decodeFromString<SongRequest>(text)
@@ -121,45 +142,58 @@ fun Routing.wsSongRoutes() {
                                 }
                             }
                         }
+
                         is Frame.Ping -> send(Frame.Pong(frame.data))
                         else -> {}
                     }
                 }
-        } catch(e: ClosedReceiveChannelException) {
+            } catch (e: ClosedReceiveChannelException) {
-            logger.error("Error in WebSocket: ${e.message}")
+                logger.error("WebSocket connection closed for user $uid: ${e.message}")
+            } catch (e: Exception) {
+                logger.error("Unexpected error in WebSocket for user $uid", e)
             } finally {
+                logger.info("Cleaning up WebSocket connection for user $uid")
                 removeSession(uid, this)
                 ackMap[uid]?.remove(this)
+                heartbeatJob.cancel()
+            }
+        } catch(e: Exception) {
+            logger.error("Unexpected error in WebSocket for user $uid", e)
         }
     }
 
     dispatcher.subscribe(SongEvent::class) {
         logger.debug("SongEvent: {} / {} {}", it.uid, it.type, it.current?.name)
         songScope.launch {
-            broadcastMessage(it.uid, SongResponse(
+            broadcastMessage(
+                it.uid, SongResponse(
                     it.type.value,
                     it.uid,
                     it.reqUid,
                     it.current?.toSerializable(),
                     it.next?.toSerializable(),
                     it.delUrl
-            ))
+                )
+            )
         }
     }
     dispatcher.subscribe(TimerEvent::class) {
-        if(it.type == TimerType.STREAM_OFF) {
+        if (it.type == TimerType.STREAM_OFF) {
             songScope.launch {
-                broadcastMessage(it.uid, SongResponse(
+                broadcastMessage(
+                    it.uid, SongResponse(
                         it.type.value,
                         it.uid,
                         null,
                         null,
                         null,
-                ))
+                    )
+                )
             }
         }
     }
 }
+
 @Serializable
 data class SerializableYoutubeVideo(
     val url: String,