Merge pull request #45 from dalbodeule/develop

RegisterCommand some fix
2025-08-07 12:51:13 +00:00 · 2024-08-08 10:12:49 +09:00 · 2024-08-08 09:42:37 +09:00 · 2024-08-07 13:18:05 +09:00 · 2024-08-07 13:12:38 +09:00 · 2024-08-07 08:59:19 +09:00
69 changed files with 2789 additions and 527 deletions
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -1,53 +0,0 @@
-name: build
-
-# event trigger: main 브랜치에 push 이벤트 발생 시 jobs가 실행된다.
-on:
-  push:
-    branches: [ "main" ]
-
-# 권한 설정
-permissions:
-  contents: read
-
-# jobs 정의
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v2
-
-      - name: Set up JDK 21
-        uses: graalvm/setup-graalvm@v1
-        with:
-          java-version: '21'
-          distribution: 'graalvm'
-
-      - name: Build with Gradle
-        run: ./gradlew build
-
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v2
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
-
-      - name: Log in to Docker Hub
-        uses: docker/login-action@v2
-        with:
-          username: ${{ secrets.DOCKER_USERNAME }}
-          password: ${{ secrets.DOCKER_PASSWORD }}
-
-      - name: Set datetime variable
-        id: vars
-        run: echo "DATETIME=$(date +'%Y%m%d%H%M')" >> $GITHUB_ENV
-
-      - name: Build and push Docker image
-        uses: docker/build-push-action@v2
-        with:
-          context: .
-          platforms: linux/amd64,linux/arm64
-          push: true
-          tags: |
-            ${{ secrets.DOCKER_USERNAME }}/chzzkbot:${{ env.DATETIME }}
-            ${{ secrets.DOCKER_USERNAME }}/chzzkbot:latest
--- a/.idea/.gitignore
+++ b/.idea/.gitignore
@@ -6,3 +6,5 @@
 # Datasource local storage ignored files
 /dataSources/
 /dataSources.local.xml
+discord.xml
+inspectionProfiles/Project_Default.xml
--- a/.idea/dataSources.xml
+++ b/.idea/dataSources.xml
@@ -1,14 +1,15 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="DataSourceManagerImpl" format="xml" multifile-model="true">
-    <data-source source="LOCAL" name="@localhost" uuid="90f8ee11-600e-4155-a316-e8062c7c828b">
-      <driver-ref>mysql.8</driver-ref>
+    <data-source source="LOCAL" name="@prod" uuid="90f8ee11-600e-4155-a316-e8062c7c828b">
+      <driver-ref>mariadb</driver-ref>
      <synchronize>true</synchronize>
-      <jdbc-driver>com.mysql.cj.jdbc.Driver</jdbc-driver>
-      <jdbc-url>jdbc:mysql://localhost:3306</jdbc-url>
+      <jdbc-driver>org.mariadb.jdbc.Driver</jdbc-driver>
+      <jdbc-url>jdbc:mariadb://localhost:3306</jdbc-url>
      <jdbc-additional-properties>
        <property name="com.intellij.clouds.kubernetes.db.host.port" />
        <property name="com.intellij.clouds.kubernetes.db.enabled" value="false" />
+        <property name="com.intellij.clouds.kubernetes.db.resource.type" value="Deployment" />
        <property name="com.intellij.clouds.kubernetes.db.container.port" />
      </jdbc-additional-properties>
      <working-dir>$ProjectFileDir$</working-dir>
--- a/.idea/ktor.xml
+++ b/.idea/ktor.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="KtorOptions">
+    <option name="updateOpenAPI" value="true" />
+  </component>
+</project>
--- a/.idea/sqldialects.xml
+++ b/.idea/sqldialects.xml
@@ -3,7 +3,4 @@
  <component name="SqlDialectMappings">
    <file url="PROJECT" dialect="MariaDB" />
  </component>
-  <component name="SqlResolveMappings">
-    <file url="file://$PROJECT_DIR$/src/main/kotlin/space/mori/chzzk_bot/models/Command.kt" scope="{&quot;node&quot;:{  &quot;@negative&quot;:&quot;1&quot;,  &quot;group&quot;:{   &quot;@kind&quot;:&quot;root&quot;,   &quot;node&quot;:{    &quot;@negative&quot;:&quot;1&quot;   }  } }}" />
-  </component>
 </project>
--- a/19
+++ b/19
@@ -1,23 +1,10 @@
-# Stage 1: Build the JAR file
-FROM gradle:jdk21 as build
-
-WORKDIR /app
-
-# Copy the Gradle files and source code
-COPY build.gradle.kts settings.gradle.kts gradlew gradle.properties ./
-COPY gradle gradle
-COPY src src
-
-# Build the project using Gradle
-RUN ./gradlew build
-
-# Stage 2: Run the JAR file using JDK 21
+# Use a base image with JDK 21 for the final image
 FROM openjdk:21-jdk

 WORKDIR /app

-# Copy the JAR file from the build stage
-COPY --from=build /app/build/libs/*.jar app.jar
+# Copy the JAR file from the TeamCity build artifacts
+COPY build/libs/chzzk_bot-*.jar app.jar

 # Set the entry point
 ENTRYPOINT ["java", "-jar", "app.jar"]
--- a/README.md
+++ b/README.md
@@ -1,3 +1,81 @@
-# maybe_chzzk_bot_kotlin
+# nabot_chzzk_bot

-[discord](https://discord.gg/up8ANZegmy)
+[![Discord](https://img.shields.io/discord/1250093195870867577)](https://discord.gg/up8ANZegmy)&nbsp; &nbsp;[![Build Status](https://teamcity.mori.space/app/rest/builds/buildType:NabotChzzkBot_Build/statusIcon)](https://teamcity.mori.space/project/NabotChzzkBot)&nbsp; &nbsp;[![Docker Image Version](https://img.shields.io/docker/v/dalbodeule/chzzkbot)](https://hub.docker.com/repository/docker/dalbodeule/chzzkbot/general)
+
+## Chzzk Chatbot with [JDA5](https://github.com/discord-jda/JDA), [chzzk4j](https://github.com/R2turnTrue/chzzk4j)
+
+네이버 게임스트리밍 플랫폼 치지직의 챗봇입니다.
+
+## 지원 기능
+
+### Placeholders
+
+- [x] \<name>
+- [x] \<following>
+- [x] \<counter:counter_name>
+- [x] \<personal_counter:counter_name>
+- [x] \<daily_counter:counter_name>
+- [x] \<days:yyyy-mm-dd>
+
+### 관리 명령어 (on Discord)
+- [x] /register chzzk_id: \[치지직 고유ID]
+- [x] /alert channel: \[디스코드 Channel ID] content: \[알림 내용]
+- [x] /add label: \[명령어] content: \[내용]
+- [ ] /list
+- [x] /update label: \[명령어] content: \[내용]
+- [x] /delete label: \[명령어]
+### 매니저 명령어 (on Discord)
+- [x] /addmanager user: \[Discord user]
+- [x] /listmanager
+- [x] /removemanager user: \[Discord user]
+### 관리 명령어 (on Chzzk chat)
+- [x] !명령어추가 \[명령어] \[내용]
+- [x] !명령어수정 \[명령어] \[내용]
+- [x] !명령어삭제 \[명령어]
+### 타이머 명령어 (on Chzzk chat, 매니저/스트리머 전용)
+- [x] !시간 \[숫자: 분]
+- [x] !시간 업타임
+- [x] !시간 삭제
+### 플레이리스트 명령어 (on Chzzk chat)
+- [x] !노래추가 \[유튜브 주소]
+- [x] !노래목록
+- [ ] !노래삭제 \[번호]
+- [ ] !노래설정 \[내용] \[켜기/끄기]
+
+### Envs
+- DISCORD_TOKEN
+- DB_URL
+- DB_USER
+- DB_PASS
+- RUN_AGENT = `false`
+- NID_AUT
+- NID_SES
+
+### 사용 예시
+- 팔로우
+  - `/add label: !팔로우 content: <name>님은 오늘로 <following>일째 팔로우네요!`
+- 출첵
+  - `/add label: !출첵 content: <name>님의 <daily_counter:attendance>번째 출석! fail_content: <name>님은 오늘 이미 출석했어요! <daily_counter:attendance>번 했네요?`
+  - `/add label: ? content: <name>님이 <counter:hook>개째 갈고리 수집`
+- ㄱㅇㅇ
+  - `/add label: ㄱㅇㅇ content: <counter:cute>번째 ㄱㅇㅇ`
+  - `/add label: ㄱㅇㅇ content:  나누 귀여움 +<counter:cute>`
+- 풉
+  - `/add label: 풉 content: <counter:poop>번째 비웃음?`
+  - `/add label: 풉키풉키 content: <counter:poop>번째 비웃음?`
+- 바보
+  - `/add label: 바보 content: 나 바보 아니다?`
+  - `/add label: 바보 content: <counter:fool> 번째 바보? 나 바보 아니다?`
+- 첫방송
+  - `/add label: 첫방송 content: 24년 7월 23일부터 <days:2024-07-23>일 째 방송중!`
+
+## 사용 기술스택
+- [Exposed](https://github.com/JetBrains/Exposed)
+- [Kotlin](https://github.com/JetBrains/kotlin)
+- [JDA5](https://github.com/discord-jda/JDA)
+- [chzzk4j](https://github.com/R2turnTrue/chzzk4j)
+- [HikariCP](https://github.com/brettwooldridge/HikariCP)
+- [gson](https://github.com/google/gson)
+- [mariadb](https://mariadb.org/)
+- [docker](https://www.docker.com/)
+- [Teamcity](https://www.jetbrains.com/teamcity/)
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -5,7 +5,6 @@ plugins {
    id("application")
    kotlin("jvm") version kotlinVersion
    kotlin("plugin.jpa") version kotlinVersion
-    id("org.graalvm.buildtools.native") version "0.10.2"
 }

 group = "${project.group}"
@@ -28,40 +27,28 @@ repositories {
 }

 dependencies {
-    // https://mvnrepository.com/artifact/net.dv8tion/JDA
-    implementation("net.dv8tion:JDA:5.0.0-beta.24") {
-        exclude(module = "opus-java")
-    }
-    // https://mvnrepository.com/artifact/io.github.R2turnTrue/chzzk4j
-    implementation("io.github.R2turnTrue:chzzk4j:0.0.8")
-
-    implementation("ch.qos.logback:logback-classic:1.4.14")
-
-    // https://mvnrepository.com/artifact/org.jetbrains.exposed/exposed-core
-    implementation("org.jetbrains.exposed:exposed-core:0.51.1")
-    // https://mvnrepository.com/artifact/org.jetbrains.exposed/exposed-dao
-    implementation("org.jetbrains.exposed:exposed-dao:0.51.1")
-    // https://mvnrepository.com/artifact/org.jetbrains.exposed/exposed-jdbc
-    implementation("org.jetbrains.exposed:exposed-jdbc:0.51.1")
-    // https://mvnrepository.com/artifact/org.jetbrains.exposed/exposed-kotlin-datetime
-    implementation("org.jetbrains.exposed:exposed-java-time:0.51.1")
-
-    // https://mvnrepository.com/artifact/com.zaxxer/HikariCP
-    implementation("com.zaxxer:HikariCP:5.1.0")
+    // https://mvnrepository.com/artifact/ch.qos.logback/logback-classic
+    implementation("ch.qos.logback:logback-classic:1.5.6")

    // https://mvnrepository.com/artifact/org.jetbrains.kotlinx/kotlinx-coroutines-core
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0-RC")
    // https://mvnrepository.com/artifact/org.jetbrains.kotlin/kotlin-reflect
    implementation("org.jetbrains.kotlin:kotlin-reflect:2.0.0")

+    // https://mvnrepository.com/artifact/com.google.code.gson/gson
    implementation("com.google.code.gson:gson:2.11.0")

-    // https://mvnrepository.com/artifact/org.mariadb.jdbc/mariadb-java-client
-    implementation("org.mariadb.jdbc:mariadb-java-client:3.4.0")
-
+    // https://mvnrepository.com/artifact/io.github.cdimascio/dotenv-kotlin
    implementation("io.github.cdimascio:dotenv-kotlin:6.4.1")

+    // https://mvnrepository.com/artifact/io.insert-koin/koin-core
+    implementation("io.insert-koin:koin-core:4.0.0-RC1")
+
    kotlin("stdlib")
+
+    listOf(project(":common"), project(":chatbot"), project(":webserver")).forEach {
+        implementation(it)
+    }
 }

 tasks.withType<Jar> {
@@ -77,4 +64,8 @@ tasks.withType<Jar> {
    })

    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+}
+
+tasks.named<JavaExec>("run") {
+    systemProperty("logback.configurationFile", "logback-debug.xml")
 }
--- a/chatbot/build.gradle.kts
+++ b/chatbot/build.gradle.kts
@@ -0,0 +1,53 @@
+plugins {
+    kotlin("jvm")
+}
+
+group = project.rootProject.group
+version = project.rootProject.version
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    // https://mvnrepository.com/artifact/net.dv8tion/JDA
+    api("net.dv8tion:JDA:5.0.1") {
+        exclude(module = "opus-java")
+    }
+
+    // https://mvnrepository.com/artifact/io.github.R2turnTrue/chzzk4j
+    implementation("io.github.R2turnTrue:chzzk4j:0.0.9")
+
+    // https://mvnrepository.com/artifact/ch.qos.logback/logback-classic
+    implementation("ch.qos.logback:logback-classic:1.5.6")
+
+    // https://mvnrepository.com/artifact/org.jetbrains.kotlinx/kotlinx-coroutines-core
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0-RC")
+    // https://mvnrepository.com/artifact/org.jetbrains.kotlin/kotlin-reflect
+    implementation("org.jetbrains.kotlin:kotlin-reflect:2.0.0")
+
+    // https://mvnrepository.com/artifact/com.google.code.gson/gson
+    implementation("com.google.code.gson:gson:2.11.0")
+
+    // https://mvnrepository.com/artifact/io.github.cdimascio/dotenv-kotlin
+    implementation("io.github.cdimascio:dotenv-kotlin:6.4.1")
+
+    // https://mvnrepository.com/artifact/com.squareup.okhttp3/okhttp
+    implementation("com.squareup.okhttp3:okhttp:4.12.0")
+
+    // https://mvnrepository.com/artifact/io.insert-koin/koin-core
+    implementation("io.insert-koin:koin-core:4.0.0-RC1")
+
+    testImplementation(kotlin("test"))
+
+    listOf(project(":common")).forEach {
+        implementation(it)
+    }
+}
+
+tasks.test {
+    useJUnitPlatform()
+}
+kotlin {
+    jvmToolchain(21)
+}
--- a/chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/chzzk/ChzzkHandler.kt
+++ b/chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/chzzk/ChzzkHandler.kt
@@ -1,37 +1,51 @@
-package space.mori.chzzk_bot.chzzk
+package space.mori.chzzk_bot.chatbot.chzzk

-import net.dv8tion.jda.api.EmbedBuilder
-import net.dv8tion.jda.api.utils.messages.MessageCreateBuilder
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+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.chzzk.Connector.chzzk
-import space.mori.chzzk_bot.discord
-import space.mori.chzzk_bot.models.User
-import space.mori.chzzk_bot.services.UserService
+import space.mori.chzzk_bot.chatbot.chzzk.Connector.chzzk
+import space.mori.chzzk_bot.chatbot.discord.Discord
+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.chat.ChatEventListener
 import xyz.r2turntrue.chzzk4j.chat.ChatMessage
 import xyz.r2turntrue.chzzk4j.chat.ChzzkChat
 import xyz.r2turntrue.chzzk4j.types.channel.ChzzkChannel
 import java.lang.Exception
 import java.net.SocketTimeoutException
-import java.time.Instant
+import java.time.LocalDateTime

 object ChzzkHandler {
    private val handlers = mutableListOf<UserHandler>()
    private val logger = LoggerFactory.getLogger(this::class.java)
+    lateinit var botUid: String
    @Volatile private var running: Boolean = false

-    internal fun addUser(chzzkChannel: ChzzkChannel, user: User) {
-        handlers.add(UserHandler(chzzkChannel, logger, user))
+    fun addUser(chzzkChannel: ChzzkChannel, user: User) {
+        handlers.add(UserHandler(chzzkChannel, logger, user, streamStartTime = null))
    }

-    internal fun enable() {
+    fun enable() {
+        botUid = chzzk.loggedUser.userId
        UserService.getAllUsers().map {
-            chzzk.getChannel(it.token)?.let { token -> addUser(token, it)}
+            chzzk.getChannel(it.token)?.let { token -> addUser(token, it) }
+        }
+
+        handlers.forEach { handler ->
+            val streamInfo = getStreamInfo(handler.listener.channelId)
+            if (streamInfo.content?.status == "OPEN") handler.isActive(true, streamInfo)
        }
    }

-    internal fun disable() {
+    fun disable() {
        handlers.forEach { handler ->
            handler.disable()
        }
@@ -53,7 +67,7 @@ object ChzzkHandler {
            throw RuntimeException("${chzzkChannel.channelName} doesn't have handler")
    }

-    internal fun runStreamInfo() {
+    fun runStreamInfo() {
        running = true
        val thread = Thread({
            while(running) {
@@ -61,8 +75,8 @@ object ChzzkHandler {
                    if (!running) return@forEach
                    try {
                        val streamInfo = getStreamInfo(it.channel.channelId)
-                        if (streamInfo.content.status == "OPEN" && !it.isActive) it.isActive(true, streamInfo)
-                        if (streamInfo.content.status == "CLOSE" && it.isActive) it.isActive(false, streamInfo)
+                        if (streamInfo.content?.status == "OPEN" && !it.isActive) it.isActive(true, streamInfo)
+                        if (streamInfo.content?.status == "CLOSE" && it.isActive) it.isActive(false, streamInfo)
                    } catch(e: SocketTimeoutException) {
                        logger.info("Timeout: ${it.channel.channelName} / ${e.stackTraceToString()}")
                    } catch (e: Exception) {
@@ -78,25 +92,31 @@ object ChzzkHandler {
        thread.start()
    }

-    internal fun stopStreamInfo() {
+    fun stopStreamInfo() {
        running = false
    }
 }

 class UserHandler(
    val channel: ChzzkChannel,
-    private val logger: Logger,
+    val logger: Logger,
    private var user: User,
-    private var _isActive: Boolean = false
+    var streamStartTime: LocalDateTime?,
 ) {
    private lateinit var messageHandler: MessageHandler
+    private val dispatcher: CoroutinesEventBus by inject(CoroutinesEventBus::class.java)
+    private var _isActive: Boolean
+        get() = LiveStatusService.getLiveStatus(user)?.status ?: false
+        set(value) {
+            LiveStatusService.updateOrCreate(user, value)
+        }

-    private var listener: ChzzkChat = chzzk.chat(channel.channelId)
+    var listener: ChzzkChat = chzzk.chat(channel.channelId)
        .withAutoReconnect(true)
        .withChatListener(object : ChatEventListener {
            override fun onConnect(chat: ChzzkChat, isReconnecting: Boolean) {
                logger.info("ChzzkChat connected. ${channel.channelName} - ${channel.channelId} / reconnected: $isReconnecting")
-                messageHandler = MessageHandler(channel, logger, chat)
+                messageHandler = MessageHandler(this@UserHandler)
            }

            override fun onError(ex: Exception) {
@@ -131,39 +151,69 @@ class UserHandler(
    internal val isActive: Boolean
        get() = _isActive

-    internal fun isActive(value: Boolean, status: IData<IStreamInfo>) {
-        _isActive = value
+    internal fun isActive(value: Boolean, status: IData<IStreamInfo?>) {
        if(value) {
            logger.info("${user.username} is live.")

            logger.info("ChzzkChat connecting... ${channel.channelName} - ${channel.channelId}")
-            listener.connectAsync()
+            listener.connectBlocking()

-            if(user.liveAlertMessage != "" && user.liveAlertGuild != null && user.liveAlertChannel != null) {
-                val channel = discord.getChannel(user.liveAlertGuild!!, user.liveAlertChannel!!) ?: throw RuntimeException("${user.liveAlertChannel} is not valid.")
+            streamStartTime = status.content?.openDate?.let { convertChzzkDateToLocalDateTime(it) }

-                val embed = EmbedBuilder()
-                embed.setTitle(status.content.liveTitle, "https://chzzk.naver.com/live/${user.token}")
-                embed.setDescription("${user.username} 님이 방송을 시작했습니다.")
-                embed.setUrl(status.content.channel.channelImageUrl)
-                embed.setTimestamp(Instant.now())
-                embed.setAuthor(user.username, "https://chzzk.naver.com/live/${user.token}", status.content.channel.channelImageUrl)
-                embed.addField("카테고리", status.content.liveCategoryValue, true)
-                embed.addField("태그", status.content.tags.joinToString(", "), true)
-                embed.setImage(status.content.liveImageUrl.replace("{type}", "1080"))
+            CoroutineScope(Dispatchers.Default).launch {
+                if(!_isActive) {
+                    when(TimerConfigService.getConfig(UserService.getUser(channel.channelId)!!)?.option) {
+                        TimerType.UPTIME.value -> dispatcher.post(
+                            TimerEvent(
+                                channel.channelId,
+                                TimerType.UPTIME,
+                                getUptime(streamStartTime!!)
+                            )
+                        )

-                channel.sendMessage(
-                    MessageCreateBuilder()
-                        .setContent(user.liveAlertMessage)
-                        .setEmbeds(embed.build())
-                        .build()
-                ).queue()
-
-                listener.sendChat("${user.username} 님의 방송이 감지되었습니다.")
+                        else -> dispatcher.post(
+                            TimerEvent(
+                                channel.channelId,
+                                TimerType.REMOVE,
+                                ""
+                            )
+                        )
+                    }
+                    delay(5000L)
+                    try {
+                        listener.sendChat("${user.username} 님! 오늘도 열심히 방송하세요!")
+                        Discord.sendDiscord(user, status)
+                    } catch(e: Exception) {
+                        logger.info("Stream on logic has some error: ${e.stackTraceToString()}")
+                    }
+                }
            }
        } else {
            logger.info("${user.username} is offline.")
+            streamStartTime = null
            listener.closeAsync()
+
+            CoroutineScope(Dispatchers.Default).launch {
+                val events = listOf(
+                    TimerEvent(
+                        channel.channelId,
+                        TimerType.STREAM_OFF,
+                        null
+                    ),
+                    SongEvent(
+                        channel.channelId,
+                        SongType.STREAM_OFF,
+                        null,
+                        null,
+                        null,
+                        null,
+                        null,
+                        null
+                    )
+                )
+                events.forEach { dispatcher.post(it) }
+            }
        }
+        _isActive = value
    }
 }
--- a/chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/chzzk/Connector.kt
+++ b/chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/chzzk/Connector.kt
@@ -1,10 +1,14 @@
-package space.mori.chzzk_bot.chzzk
+package space.mori.chzzk_bot.chatbot.chzzk

+import io.github.cdimascio.dotenv.dotenv
 import org.slf4j.LoggerFactory
 import xyz.r2turntrue.chzzk4j.Chzzk
 import xyz.r2turntrue.chzzk4j.ChzzkBuilder
 import xyz.r2turntrue.chzzk4j.types.channel.ChzzkChannel
-import space.mori.chzzk_bot.dotenv
+
+val dotenv = dotenv {
+    ignoreIfMissing = true
+}

 object Connector {
    val chzzk: Chzzk = ChzzkBuilder()
--- a/chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/chzzk/MessageHandler.kt
+++ b/chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/chzzk/MessageHandler.kt
@@ -0,0 +1,381 @@
+package space.mori.chzzk_bot.chatbot.chzzk
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import org.koin.java.KoinJavaComponent.inject
+import space.mori.chzzk_bot.chatbot.discord.Discord.Companion.bot
+import space.mori.chzzk_bot.common.events.*
+import space.mori.chzzk_bot.common.models.User
+import space.mori.chzzk_bot.common.services.*
+import space.mori.chzzk_bot.common.utils.getFollowDate
+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 java.time.LocalDateTime
+import java.time.format.DateTimeFormatter
+import java.time.temporal.ChronoUnit
+import java.util.UUID
+
+
+class MessageHandler(
+    private val handler: UserHandler
+) {
+    private val commands = mutableMapOf<String, (msg: ChatMessage, user: User) -> Unit>()
+
+    private val counterPattern = Regex("<counter:([^>]+)>")
+    private val personalCounterPattern = Regex("<counter_personal:([^>]+)>")
+    private val dailyCounterPattern = Regex("<daily_counter:([^>]+)>")
+    private val namePattern = Regex("<name>")
+    private val followPattern = Regex("<following>")
+    private val daysPattern = """<days:(\d{4})-(\d{2})-(\d{2})>""".toRegex()
+
+    private val channel = handler.channel
+    private val logger = handler.logger
+    private val listener = handler.listener
+
+    private val dispatcher: CoroutinesEventBus by inject(CoroutinesEventBus::class.java)
+
+    init {
+        reloadCommand()
+        dispatcher.subscribe(SongEvent::class) {
+            if(it.type == SongType.STREAM_OFF) {
+                val user = UserService.getUser(channel.channelId)
+                if(! user?.let { usr -> SongListService.getSong(usr) }.isNullOrEmpty()) {
+                    SongListService.deleteUser(user!!)
+                }
+            }
+        }
+    }
+
+    internal fun reloadCommand() {
+        val user = UserService.getUser(channel.channelId)
+            ?: throw RuntimeException("User not found. it's bug? ${channel.channelName} - ${channel.channelId}")
+        val commands = CommandService.getCommands(user)
+        val manageCommands = mapOf(
+            "!명령어추가" to this::manageAddCommand,
+            "!명령어삭제" to this::manageRemoveCommand,
+            "!명령어수정" to this::manageUpdateCommand,
+            "!시간" to this::timerCommand,
+            "!노래추가" to this::songAddCommand,
+            "!노래목록" to this::songListCommand,
+            "!노래시작" to this::songStartCommand
+        )
+
+        manageCommands.forEach { (commandName, command) ->
+            this.commands[commandName] = command
+        }
+
+        commands.map {
+            this.commands.put(it.command.lowercase()) { msg, user ->
+                logger.debug("${channel.channelName} - ${it.command} - ${it.content}/${it.failContent}")
+
+                val result = replaceCounters(Pair(it.content, it.failContent), user, msg, listener, msg.profile?.nickname ?: "")
+                listener.sendChat(result)
+            }
+        }
+    }
+
+    private fun manageAddCommand(msg: ChatMessage, user: User) {
+        if (msg.profile?.userRoleCode == "common_user") {
+            listener.sendChat("매니저만 명령어를 추가할 수 있습니다.")
+            return
+        }
+
+        val parts = msg.content.split(" ", limit = 3)
+        if (parts.size < 3) {
+            listener.sendChat("명령어 추가 형식은 '!명령어추가 명령어 내용'입니다.")
+            return
+        }
+        if (commands.containsKey(parts[1])) {
+            listener.sendChat("${parts[1]} 명령어는 이미 있는 명령어입니다.")
+            return
+        }
+        val command = parts[1]
+        val content = parts[2]
+        CommandService.saveCommand(user, command, content, "")
+        listener.sendChat("명령어 '$command' 추가되었습니다.")
+    }
+
+    private fun manageUpdateCommand(msg: ChatMessage, user: User) {
+        if (msg.profile?.userRoleCode == "common_user") {
+            listener.sendChat("매니저만 명령어를 추가할 수 있습니다.")
+            return
+        }
+
+        val parts = msg.content.split(" ", limit = 3)
+        if (parts.size < 3) {
+            listener.sendChat("명령어 수정 형식은 '!명령어수정 명령어 내용'입니다.")
+            return
+        }
+        if (!commands.containsKey(parts[1])) {
+            listener.sendChat("${parts[1]} 명령어는 없는 명령어입니다.")
+            return
+        }
+        val command = parts[1]
+        val content = parts[2]
+        CommandService.updateCommand(user, command, content, "")
+        listener.sendChat("명령어 '$command' 수정되었습니다.")
+        ChzzkHandler.reloadCommand(channel)
+    }
+
+    private fun manageRemoveCommand(msg: ChatMessage, user: User) {
+        if (msg.profile?.userRoleCode == "common_user") {
+            listener.sendChat("매니저만 명령어를 삭제할 수 있습니다.")
+            return
+        }
+
+        val parts = msg.content.split(" ", limit = 2)
+        if (parts.size < 2) {
+            listener.sendChat("명령어 삭제 형식은 '!명령어삭제 명령어'입니다.")
+            return
+        }
+        val command = parts[1]
+        CommandService.removeCommand(user, command)
+        listener.sendChat("명령어 '$command' 삭제되었습니다.")
+        ChzzkHandler.reloadCommand(channel)
+    }
+
+    private fun timerCommand(msg: ChatMessage, user: User) {
+        if (msg.profile?.userRoleCode == "common_user") {
+            listener.sendChat("매니저만 이 명령어를 사용할 수 있습니다.")
+            return
+        }
+
+        val parts = msg.content.split(" ", limit = 3)
+        if (parts.size < 2) {
+            listener.sendChat("타이머 명령어 형식을 잘 찾아봐주세요!")
+            return
+        }
+
+        val command = parts[1]
+        when (parts[1]) {
+            "업타임" -> {
+                logger.debug("${user.token} / 업타임")
+
+                CoroutineScope(Dispatchers.Default).launch {
+                    dispatcher.post(
+                        TimerEvent(
+                            user.token,
+                            TimerType.UPTIME,
+                            getUptime(handler.streamStartTime!!)
+                        )
+                    )
+                }
+            }
+            "삭제" -> {
+                logger.debug("${user.token} / 삭제")
+                CoroutineScope(Dispatchers.Default).launch {
+                    dispatcher.post(TimerEvent(user.token, TimerType.REMOVE, ""))
+                }
+            }
+            "설정" -> {
+                when (parts[2]) {
+                    "업타임" -> {
+                        TimerConfigService.saveOrUpdateConfig(user, TimerType.UPTIME)
+                        listener.sendChat("기본 타이머 설정이 업타임으로 바뀌었습니다.")
+                    }
+                    "삭제" -> {
+                        TimerConfigService.saveOrUpdateConfig(user, TimerType.REMOVE)
+                        listener.sendChat("기본 타이머 설정이 삭제로 바뀌었습니다.")
+                    }
+                    else -> listener.sendChat("!타이머 설정 (업타임/삭제) 형식으로 써주세요!")
+                }
+            }
+            else -> {
+                logger.debug("${user.token} / 그외")
+                try {
+                    val time = command.toInt()
+                    val currentTime = LocalDateTime.now()
+                    val timestamp = currentTime.plus(time.toLong(), ChronoUnit.MINUTES)
+
+                    CoroutineScope(Dispatchers.Default).launch {
+                        dispatcher.post(TimerEvent(user.token, TimerType.TIMER, timestamp.toString()))
+                    }
+                } catch (e: NumberFormatException) {
+                    listener.sendChat("!타이머/숫자 형식으로 적어주세요! 단위: 분")
+                } catch (e: Exception) {
+                    listener.sendChat("타이머 설정 중 오류가 발생했습니다.")
+                    logger.error("Error processing timer command: ${e.message}", e)
+                }
+            }
+        }
+    }
+
+    // songs
+    private fun songAddCommand(msg: ChatMessage, user: User) {
+        val parts = msg.content.split(" ", limit = 3)
+        if (parts.size < 2) {
+            listener.sendChat("유튜브 URL을 입력해주세요!")
+            return
+        }
+
+        val config = SongConfigService.getConfig(user)
+
+        if(config.streamerOnly && msg.profile?.userRoleCode == "common_user") {
+            listener.sendChat("매니저만 이 명령어를 사용할 수 있습니다.")
+            return
+        }
+
+        val url = parts[1]
+        val songs = SongListService.getSong(user)
+
+        if(songs.size >= config.queueLimit) {
+            listener.sendChat("더이상 노래를 신청할 수 없습니다. 잠시 뒤 다시 시도해주세요!")
+            return
+        }
+        if(songs.filter { it.uid == msg.userId }.size  >= config.personalLimit) {
+            listener.sendChat("더이상 노래를 신청할 수 없습니다. 잠시 뒤 다시 시도해주세요!")
+            return
+        }
+
+        try {
+            val video = getYoutubeVideo(url)
+            if (video == null) {
+                listener.sendChat("유튜브에서 찾을 수 없어요!")
+                return
+            }
+
+            if (songs.any { it.url == video.url }) {
+                listener.sendChat("같은 노래가 이미 신청되어 있습니다.")
+                return
+            }
+
+            SongListService.saveSong(
+                user,
+                msg.userId,
+                video.url,
+                video.name,
+                video.author,
+                video.length,
+                msg.profile?.nickname ?: ""
+            )
+            CoroutineScope(Dispatchers.Default).launch {
+                dispatcher.post(
+                    SongEvent(
+                        user.token,
+                        SongType.ADD,
+                        msg.userId,
+                        msg.profile?.nickname ?: "",
+                        video.name,
+                        video.author,
+                        video.length,
+                        video.url
+                    )
+                )
+            }
+
+            listener.sendChat("노래가 추가되었습니다.")
+        } catch(e: Exception) {
+            listener.sendChat("유튜브 영상 주소로 다시 신청해주세요!")
+            logger.info(e.stackTraceToString())
+        }
+    }
+
+    private fun songListCommand(msg: ChatMessage, user: User) {
+        listener.sendChat("리스트는 여기입니다. https://nabot.mori.space/songs/${user.token}")
+    }
+
+    private fun songStartCommand(msg: ChatMessage, user: User) {
+        if (msg.profile?.userRoleCode == "common_user") {
+            listener.sendChat("매니저만 이 명령어를 사용할 수 있습니다.")
+            return
+        }
+
+        val session = "${UUID.randomUUID()}${UUID.randomUUID()}".replace("-", "")
+
+        SongConfigService.updateSession(user, session)
+
+
+        bot.retrieveUserById(user.discord).queue { discordUser ->
+            discordUser?.openPrivateChannel()?.queue { channel ->
+                channel.sendMessage("여기로 접속해주세요! ||https://nabot.mori.space/songlist/${session}||.\n주소가 노출될 경우 방송을 다시 켜셔야 합니다!")
+                    .queue()
+            }
+        }
+    }
+
+    internal fun handle(msg: ChatMessage, user: User) {
+        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: 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.userId, user)
+
+            if (dailyCounter.second) {
+                CounterService.updateDailyCounterValue(name, msg.userId, 1, user).first.toString()
+            } else {
+                isFail = true
+                dailyCounter.first.toString()
+            }
+        }
+
+        // Handle fail case
+        if (isFail && chat.second.isNotEmpty()) {
+            result = chat.second
+            result = dailyCounterPattern.replace(result) { matchResult ->
+                val name = matchResult.groupValues[1]
+                val dailyCounter = CounterService.getDailyCounterValue(name, msg.userId, user)
+                dailyCounter.first.toString()
+            }
+        }
+
+        // Replace followPattern
+        result = followPattern.replace(result) { _ ->
+            try {
+                val followingDate = getFollowDate(listener.chatId, msg.userId)
+                    .content?.streamingProperty?.following?.followDate
+
+                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
+
+                period.toString()
+            } catch (e: Exception) {
+                logger.error(e.message)
+                "0"
+            }
+        }
+
+        // Replace daysPattern
+        result = daysPattern.replace(result) { matchResult ->
+            val (year, month, day) = matchResult.destructured
+            val pastDate = LocalDateTime.of(year.toInt(), month.toInt(), day.toInt(), 0, 0, 0)
+            val today = LocalDateTime.now()
+
+            val daysBetween = ChronoUnit.DAYS.between(pastDate, today)
+            daysBetween.toString()
+        }
+
+        // Replace counterPattern
+        result = counterPattern.replace(result) { matchResult ->
+            val name = matchResult.groupValues[1]
+            CounterService.updateCounterValue(name, 1, user).toString()
+        }
+
+        // Replace personalCounterPattern
+        result = personalCounterPattern.replace(result) { matchResult ->
+            val name = matchResult.groupValues[1]
+            CounterService.updatePersonalCounterValue(name, msg.userId, 1, user).toString()
+        }
+
+        // Replace namePattern
+        result = namePattern.replace(result, userName)
+
+        return result
+    }
+
+}
--- a/chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/chzzk/SongModule.kt
+++ b/chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/chzzk/SongModule.kt
@@ -0,0 +1,11 @@
+package space.mori.chzzk_bot.chatbot.chzzk
+
+import space.mori.chzzk_bot.common.models.User
+import space.mori.chzzk_bot.common.services.CommandService
+import xyz.r2turntrue.chzzk4j.chat.ChatMessage
+
+class SongModule {
+    companion object {
+
+    }
+}
--- a/chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/discord/Commands.kt
+++ b/chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/discord/Commands.kt
@@ -1,4 +1,4 @@
-package space.mori.chzzk_bot.discord
+package space.mori.chzzk_bot.chatbot.discord

 import net.dv8tion.jda.api.JDA
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
--- a/chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/discord/Discord.kt
+++ b/chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/discord/Discord.kt
@@ -0,0 +1,133 @@
+package space.mori.chzzk_bot.chatbot.discord
+
+import io.github.cdimascio.dotenv.dotenv
+import net.dv8tion.jda.api.EmbedBuilder
+import net.dv8tion.jda.api.JDA
+import net.dv8tion.jda.api.JDABuilder
+import net.dv8tion.jda.api.entities.Activity
+import net.dv8tion.jda.api.entities.Guild
+import net.dv8tion.jda.api.entities.channel.concrete.TextChannel
+import net.dv8tion.jda.api.events.guild.GuildJoinEvent
+import net.dv8tion.jda.api.events.guild.member.GuildMemberRemoveEvent
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
+import net.dv8tion.jda.api.hooks.ListenerAdapter
+import net.dv8tion.jda.api.utils.messages.MessageCreateBuilder
+import org.slf4j.LoggerFactory
+import space.mori.chzzk_bot.common.utils.IData
+import space.mori.chzzk_bot.common.utils.IStreamInfo
+import space.mori.chzzk_bot.chatbot.discord.commands.*
+import space.mori.chzzk_bot.common.models.User
+import space.mori.chzzk_bot.common.services.ManagerService
+import java.time.Instant
+
+val dotenv = dotenv {
+    ignoreIfMissing = true
+}
+
+class Discord: ListenerAdapter() {
+    private var guild: Guild? = null
+    private val logger = LoggerFactory.getLogger(this::class.java)
+
+    companion object {
+        lateinit var bot: JDA
+
+        internal fun getChannel(guildId: Long, channelId: Long): TextChannel? = bot.getGuildById(guildId)?.getTextChannelById(channelId)
+
+        fun sendDiscord(user: User, status: IData<IStreamInfo?>) {
+            if(status.content == null) return
+            if(user.liveAlertMessage != "" && user.liveAlertGuild != null && user.liveAlertChannel != null) {
+                val channel = getChannel(user.liveAlertGuild!!, user.liveAlertChannel!!) ?: throw RuntimeException("${user.liveAlertChannel} is not valid.")
+
+                val embed = EmbedBuilder()
+                embed.setTitle(status.content!!.liveTitle, "https://chzzk.naver.com/live/${user.token}")
+                embed.setDescription("${user.username} 님이 방송을 시작했습니다.")
+                embed.setTimestamp(Instant.now())
+                embed.setAuthor(user.username, "https://chzzk.naver.com/live/${user.token}", status.content!!.channel.channelImageUrl)
+                embed.addField("카테고리", status.content!!.liveCategoryValue, true)
+                embed.addField("태그", status.content!!.tags.joinToString(", "), true)
+                embed.setImage(status.content!!.liveImageUrl.replace("{type}", "1080"))
+
+                channel.sendMessage(
+                    MessageCreateBuilder()
+                        .setContent(user.liveAlertMessage)
+                        .setEmbeds(embed.build())
+                        .build()
+                ).queue()
+            }
+        }
+    }
+
+    private val commands = listOf(
+        AddCommand,
+        AlertCommand,
+        PingCommand,
+        RegisterCommand,
+        RemoveCommand,
+        UpdateCommand,
+        AddManagerCommand,
+        ListManagerCommand,
+        RemoveManagerCommand,
+    )
+
+    override fun onSlashCommandInteraction(event: SlashCommandInteractionEvent) {
+        event.deferReply().queue()
+        val handler = commands.find { it.name == event.name }
+        logger.debug("Handler: ${handler?.name ?: "undefined"} command")
+        handler?.run(event, bot)
+    }
+
+    override fun onGuildMemberRemove(event: GuildMemberRemoveEvent) {
+        event.member?.let { ManagerService.deleteManager(event.guild.idLong, it.idLong) }
+    }
+
+    override fun onGuildJoin(event: GuildJoinEvent) {
+        commandUpdate(event.guild)
+    }
+
+    private fun commandUpdate(guild: Guild) {
+        guild.updateCommands().addCommands(* commands.map { it.command}.toTypedArray())
+            .onSuccess {
+                logger.info("Command update on guild success!")
+            }
+            .queue()
+    }
+
+    private fun commandUpdate(bot: JDA) {
+        bot.updateCommands().addCommands(* commands.map { it.command}.toTypedArray())
+            .onSuccess {
+                logger.info("Command update bot boot success!")
+            }
+            .queue()
+    }
+
+    fun enable() {
+        val thread = Thread {
+            try {
+                bot = JDABuilder.createDefault(dotenv["DISCORD_TOKEN"])
+                    .setActivity(Activity.playing("치지직 보는중"))
+                    .addEventListeners(this)
+                    .build().awaitReady()
+
+                guild = bot.getGuildById(dotenv["GUILD_ID"])
+
+                commandUpdate(bot)
+                bot.guilds.forEach {
+                    commandUpdate(it)
+                }
+            } catch (e: Exception) {
+                logger.info("Could not enable Discord!")
+                logger.debug(e.stackTraceToString())
+            }
+        }
+        thread.start()
+    }
+
+    fun disable() {
+        try {
+            bot.shutdown()
+        } catch(e: Exception) {
+            logger.info("Error while shutting down Discord!")
+            logger.debug(e.stackTraceToString())
+        }
+    }
+}
--- a/chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/discord/commands/AddCommand.kt
+++ b/chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/discord/commands/AddCommand.kt
@@ -1,16 +1,18 @@
-package space.mori.chzzk_bot.discord.commands
+package space.mori.chzzk_bot.chatbot.discord.commands

 import net.dv8tion.jda.api.JDA
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
 import net.dv8tion.jda.api.interactions.commands.OptionType
 import net.dv8tion.jda.api.interactions.commands.build.Commands
 import net.dv8tion.jda.api.interactions.commands.build.OptionData
+import org.jetbrains.exposed.sql.transactions.transaction
 import org.slf4j.LoggerFactory
-import space.mori.chzzk_bot.chzzk.ChzzkHandler
-import space.mori.chzzk_bot.chzzk.Connector
-import space.mori.chzzk_bot.discord.CommandInterface
-import space.mori.chzzk_bot.services.CommandService
-import space.mori.chzzk_bot.services.UserService
+import space.mori.chzzk_bot.chatbot.chzzk.ChzzkHandler
+import space.mori.chzzk_bot.chatbot.chzzk.Connector
+import space.mori.chzzk_bot.chatbot.discord.CommandInterface
+import space.mori.chzzk_bot.common.services.CommandService
+import space.mori.chzzk_bot.common.services.ManagerService
+import space.mori.chzzk_bot.common.services.UserService

 object AddCommand : CommandInterface {
    private val logger = LoggerFactory.getLogger(this::class.java)
@@ -30,26 +32,39 @@ object AddCommand : CommandInterface {
            return
        }

-        val user = UserService.getUser(event.user.idLong)
-        if(user == null) {
-            event.hook.sendMessage("치지직 계정을 찾을 수 없습니다.").queue()
+        var user = UserService.getUser(event.user.idLong)
+        val manager = event.guild?.idLong?.let { ManagerService.getUser(it, event.user.idLong) }
+        if(user == null && manager == null) {
+            event.hook.sendMessage("당신은 이 명령어를 사용할 수 없습니다.").queue()
            return
        }

-        val commands = CommandService.getCommands(user)
+        if (manager != null) {
+            transaction {
+                user = manager.user
+            }
+            user?.let { ManagerService.updateManager(it, event.user.idLong, event.user.effectiveName) }
+        }
+
+        if (user == null) {
+            event.hook.sendMessage("에러가 발생했습니다.").queue()
+            return
+        }
+
+        val commands = CommandService.getCommands(user!!)
        if (commands.any { it.command == label }) {
            event.hook.sendMessage("$label 명령어는 이미 있습니다! 업데이트 명령어를 써주세요.").queue()
            return
        }

-        val chzzkChannel = Connector.getChannel(user.token)
+        val chzzkChannel = Connector.getChannel(user!!.token)

        try {
-            CommandService.saveCommand(user, label, content, failContent ?: "")
+            CommandService.saveCommand(user!!, label, content, failContent ?: "")
            try {
                ChzzkHandler.reloadCommand(chzzkChannel!!)
            } catch (_: Exception) {}
-            event.hook.sendMessage("등록이 완료되었습니다. $label = $content/$failContent").queue()
+            event.hook.sendMessage("등록이 완료되었습니다. $label = $content / $failContent").queue()
        } catch (e: Exception) {
            event.hook.sendMessage("에러가 발생했습니다.").queue()
            logger.debug(e.stackTraceToString())
--- a/chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/discord/commands/AddManagerCommand.kt
+++ b/chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/discord/commands/AddManagerCommand.kt
@@ -0,0 +1,47 @@
+package space.mori.chzzk_bot.chatbot.discord.commands
+
+import net.dv8tion.jda.api.JDA
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
+import net.dv8tion.jda.api.interactions.commands.OptionType
+import net.dv8tion.jda.api.interactions.commands.build.Commands
+import net.dv8tion.jda.api.interactions.commands.build.OptionData
+import org.slf4j.LoggerFactory
+import space.mori.chzzk_bot.chatbot.discord.CommandInterface
+import space.mori.chzzk_bot.common.services.ManagerService
+import space.mori.chzzk_bot.common.services.UserService
+
+object AddManagerCommand : CommandInterface {
+    private val logger = LoggerFactory.getLogger(this::class.java)
+    override val name: String = "addmanager"
+    override val command = Commands.slash(name, "매니저를 추가합니다.")
+        .addOptions(OptionData(OptionType.USER, "user", "추가할 유저를 선택하세요.", true))
+
+    override fun run(event: SlashCommandInteractionEvent, bot: JDA) {
+        val manager = event.getOption("user")?.asUser
+
+        if(manager == null) {
+            event.hook.sendMessage("유저는 필수사항입니다.").queue()
+            return
+        }
+        if(manager.idLong == event.user.idLong) {
+            event.hook.sendMessage("자신은 매니저로 설정할 수 없습니다.").queue()
+            return
+        }
+
+        val user = UserService.getUser(event.user.idLong)
+        if(user == null) {
+            event.hook.sendMessage("치지직 계정을 찾을 수 없습니다.").queue()
+            return
+        }
+
+        try {
+            ManagerService.saveManager(user, manager.idLong, manager.effectiveName)
+            if(user.liveAlertGuild == null)
+                UserService.updateLiveAlert(user.id.value, event.guild!!.idLong, event.channelIdLong, "")
+            event.hook.sendMessage("등록이 완료되었습니다. ${manager.effectiveName}").queue()
+        } catch (e: Exception) {
+            event.hook.sendMessage("에러가 발생했습니다.").queue()
+            logger.debug(e.stackTraceToString())
+        }
+    }
+}
--- a/chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/discord/commands/AlertCommand.kt
+++ b/chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/discord/commands/AlertCommand.kt
@@ -0,0 +1,59 @@
+package space.mori.chzzk_bot.chatbot.discord.commands
+
+import net.dv8tion.jda.api.JDA
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
+import net.dv8tion.jda.api.interactions.commands.OptionType
+import net.dv8tion.jda.api.interactions.commands.build.Commands
+import net.dv8tion.jda.api.interactions.commands.build.OptionData
+import org.jetbrains.exposed.sql.transactions.transaction
+import org.slf4j.LoggerFactory
+import space.mori.chzzk_bot.chatbot.chzzk.ChzzkHandler
+import space.mori.chzzk_bot.chatbot.chzzk.Connector
+import space.mori.chzzk_bot.chatbot.discord.CommandInterface
+import space.mori.chzzk_bot.common.services.ManagerService
+import space.mori.chzzk_bot.common.services.UserService
+
+object AlertCommand : CommandInterface {
+    private val logger = LoggerFactory.getLogger(this::class.java)
+    override val name: String = "alert"
+    override val command = Commands.slash(name, "방송알람 채널을 설정합니다. / 알람 취소도 이 명령어를 이용하세요!")
+        .addOptions(OptionData(OptionType.CHANNEL, "channel", "알림을 보낼 채널을 입력하세요."))
+        .addOptions(OptionData(OptionType.STRING, "content", "표시될 텍스트를 입력하세요. 비워두면 알람이 취소됩니다."))
+
+    override fun run(event: SlashCommandInteractionEvent, bot: JDA) {
+        val channel = event.getOption("channel")?.asChannel
+        val content = event.getOption("content")?.asString
+
+        var user = UserService.getUser(event.user.idLong)
+        val manager = event.guild?.idLong?.let { ManagerService.getUser(it, event.user.idLong) }
+        if(user == null && manager == null) {
+            event.hook.sendMessage("당신은 이 명령어를 사용할 수 없습니다.").queue()
+            return
+        }
+
+        if (manager != null) {
+            transaction {
+                user = manager.user
+            }
+            user?.let { ManagerService.updateManager(it, event.user.idLong, event.user.effectiveName) }
+        }
+
+        if (user == null) {
+            event.hook.sendMessage("에러가 발생했습니다.").queue()
+            return
+        }
+
+        val chzzkChannel = Connector.getChannel(user!!.token)
+
+        try {
+            val newUser = UserService.updateLiveAlert(user!!.id.value, channel?.guild?.idLong ?: 0L, channel?.idLong ?: 0L, content ?: "")
+            try {
+                ChzzkHandler.reloadUser(chzzkChannel!!, newUser)
+            } catch (_: Exception) {}
+            event.hook.sendMessage("업데이트가 완료되었습니다.").queue()
+        } catch (e: Exception) {
+            event.hook.sendMessage("에러가 발생했습니다.").queue()
+            logger.debug(e.stackTraceToString())
+        }
+    }
+}
--- a/chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/discord/commands/ListManagerCommand.kt
+++ b/chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/discord/commands/ListManagerCommand.kt
@@ -0,0 +1,44 @@
+package space.mori.chzzk_bot.chatbot.discord.commands
+
+import net.dv8tion.jda.api.EmbedBuilder
+import net.dv8tion.jda.api.JDA
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
+import net.dv8tion.jda.api.interactions.commands.build.Commands
+import org.slf4j.LoggerFactory
+import space.mori.chzzk_bot.chatbot.discord.CommandInterface
+import space.mori.chzzk_bot.common.services.ManagerService
+import space.mori.chzzk_bot.common.services.UserService
+
+object ListManagerCommand : CommandInterface {
+    private val logger = LoggerFactory.getLogger(this::class.java)
+    override val name: String = "listmanager"
+    override val command = Commands.slash(name, "매니저 목록을 확인합니다.")
+
+    override fun run(event: SlashCommandInteractionEvent, bot: JDA) {
+        try {
+            val managers = event.guild?.idLong?.let { ManagerService.getAllUsers(it) }
+
+            if(managers == null) {
+                event.channel.sendMessage("여기에서는 사용할 수 없습니다.")
+                return
+            }
+
+            val user = UserService.getUserWithGuildId(event.guild!!.idLong)
+
+            val embed = EmbedBuilder()
+            embed.setTitle("${user!!.username} 매니저 목록")
+            embed.setDescription("매니저 목록입니다.")
+
+            var idx = 1
+
+            managers.forEach {
+                embed.addField("${idx++}", it.lastUserName ?: it.managerId.toString(), true)
+            }
+
+            event.channel.sendMessageEmbeds(embed.build()).queue()
+        } catch (e: Exception) {
+            event.hook.sendMessage("에러가 발생했습니다.").queue()
+            logger.debug(e.stackTraceToString())
+        }
+    }
+}
--- a/chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/discord/commands/PingCommand.kt
+++ b/chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/discord/commands/PingCommand.kt
@@ -1,10 +1,10 @@
-package space.mori.chzzk_bot.discord.commands
+package space.mori.chzzk_bot.chatbot.discord.commands

 import net.dv8tion.jda.api.JDA
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
 import net.dv8tion.jda.api.interactions.commands.build.Commands
 import org.slf4j.LoggerFactory
-import space.mori.chzzk_bot.discord.CommandInterface
+import space.mori.chzzk_bot.chatbot.discord.CommandInterface

 object PingCommand: CommandInterface {
    private val logger = LoggerFactory.getLogger(this::class.java)
--- a/chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/discord/commands/RegisterCommand.kt
+++ b/chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/discord/commands/RegisterCommand.kt
@@ -1,25 +1,31 @@
-package space.mori.chzzk_bot.discord.commands
+package space.mori.chzzk_bot.chatbot.discord.commands

+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
 import net.dv8tion.jda.api.JDA
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
 import net.dv8tion.jda.api.interactions.commands.OptionType
 import net.dv8tion.jda.api.interactions.commands.build.Commands
 import net.dv8tion.jda.api.interactions.commands.build.OptionData
 import org.slf4j.LoggerFactory
-import space.mori.chzzk_bot.chzzk.ChzzkHandler
-import space.mori.chzzk_bot.chzzk.Connector
-import space.mori.chzzk_bot.discord.CommandInterface
-import space.mori.chzzk_bot.services.UserService
+import space.mori.chzzk_bot.chatbot.chzzk.ChzzkHandler
+import space.mori.chzzk_bot.chatbot.chzzk.Connector
+import space.mori.chzzk_bot.chatbot.discord.CommandInterface
+import space.mori.chzzk_bot.common.services.UserService

 object RegisterCommand: CommandInterface {
    private val logger = LoggerFactory.getLogger(this::class.java)
    override val name = "register"
+
+    private val regex = """(?:.+chzzk\.naver\.com/)?([a-f0-9]{32})?(?:/live)?${'$'}""".toRegex()
+
    override val command =  Commands.slash(name, "치지직 계정을 등록합니다.")
        .addOptions(
            OptionData(
                OptionType.STRING,
                "chzzk_id",
-                "36da10b7c35800f298e9c565a396bafd 형식으로 입력해주세요.",
+                "치지직 채널 URL 혹은 ID를 입력해주세요.",
                true
            )
        )
@@ -30,17 +36,22 @@ object RegisterCommand: CommandInterface {
            event.hook.sendMessage("치지직 계정은 필수 입력입니다.").queue()
            return
        }
+        val matchResult = regex.find(chzzkID)
+        val matchedChzzkId = matchResult?.groups?.get(1)?.value

-        val chzzkChannel = Connector.getChannel(chzzkID)
+        val chzzkChannel = matchedChzzkId?.let { Connector.getChannel(it) }
        if (chzzkChannel == null) {
            event.hook.sendMessage("치지직 계정을 찾을 수 없습니다.").queue()
            return
        }

        try {
+
            val user = UserService.saveUser(chzzkChannel.channelName, chzzkChannel.channelId, event.user.idLong)
+            CoroutineScope(Dispatchers.Main).launch {
+                ChzzkHandler.addUser(chzzkChannel, user)
+            }
            event.hook.sendMessage("등록이 완료되었습니다. `${chzzkChannel.channelId}` - `${chzzkChannel.channelName}`")
-            ChzzkHandler.addUser(chzzkChannel, user)
        } catch(e: Exception) {
            event.hook.sendMessage("에러가 발생했습니다.").queue()
            logger.debug(e.stackTraceToString())
--- a/chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/discord/commands/RemoveCommand.kt
+++ b/chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/discord/commands/RemoveCommand.kt
@@ -1,16 +1,18 @@
-package space.mori.chzzk_bot.discord.commands
+package space.mori.chzzk_bot.chatbot.discord.commands

 import net.dv8tion.jda.api.JDA
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
 import net.dv8tion.jda.api.interactions.commands.OptionType
 import net.dv8tion.jda.api.interactions.commands.build.Commands
 import net.dv8tion.jda.api.interactions.commands.build.OptionData
+import org.jetbrains.exposed.sql.transactions.transaction
 import org.slf4j.LoggerFactory
-import space.mori.chzzk_bot.chzzk.ChzzkHandler
-import space.mori.chzzk_bot.chzzk.Connector
-import space.mori.chzzk_bot.discord.CommandInterface
-import space.mori.chzzk_bot.services.CommandService
-import space.mori.chzzk_bot.services.UserService
+import space.mori.chzzk_bot.chatbot.chzzk.ChzzkHandler
+import space.mori.chzzk_bot.chatbot.chzzk.Connector
+import space.mori.chzzk_bot.chatbot.discord.CommandInterface
+import space.mori.chzzk_bot.common.services.CommandService
+import space.mori.chzzk_bot.common.services.ManagerService
+import space.mori.chzzk_bot.common.services.UserService

 object RemoveCommand : CommandInterface {
    private val logger = LoggerFactory.getLogger(this::class.java)
@@ -26,15 +28,29 @@ object RemoveCommand : CommandInterface {
            return
        }

-        val user = UserService.getUser(event.user.idLong)
-        if(user == null) {
-            event.hook.sendMessage("치지직 계정을 찾을 수 없습니다.").queue()
+        var user = UserService.getUser(event.user.idLong)
+        val manager = event.guild?.idLong?.let { ManagerService.getUser(it, event.user.idLong) }
+        if(user == null && manager == null) {
+            event.hook.sendMessage("당신은 이 명령어를 사용할 수 없습니다.").queue()
            return
        }
-        val chzzkChannel = Connector.getChannel(user.token)
+
+        if (manager != null) {
+            transaction {
+                user = manager.user
+            }
+            user?.let { ManagerService.updateManager(it, event.user.idLong, event.user.effectiveName) }
+        }
+
+        if (user == null) {
+            event.hook.sendMessage("에러가 발생했습니다.").queue()
+            return
+        }
+
+        val chzzkChannel = Connector.getChannel(user!!.token)

        try {
-            CommandService.removeCommand(user, label)
+            CommandService.removeCommand(user!!, label)
            try {
                ChzzkHandler.reloadCommand(chzzkChannel!!)
            } catch (_: Exception) {}
--- a/chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/discord/commands/RemoveManagerCommand.kt
+++ b/chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/discord/commands/RemoveManagerCommand.kt
@@ -0,0 +1,49 @@
+package space.mori.chzzk_bot.chatbot.discord.commands
+
+import net.dv8tion.jda.api.JDA
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
+import net.dv8tion.jda.api.interactions.commands.OptionType
+import net.dv8tion.jda.api.interactions.commands.build.Commands
+import net.dv8tion.jda.api.interactions.commands.build.OptionData
+import org.slf4j.LoggerFactory
+import space.mori.chzzk_bot.chatbot.discord.CommandInterface
+import space.mori.chzzk_bot.common.services.ManagerService
+import space.mori.chzzk_bot.common.services.UserService
+
+object RemoveManagerCommand : CommandInterface {
+    private val logger = LoggerFactory.getLogger(this::class.java)
+    override val name: String = "removemanager"
+    override val command = Commands.slash(name, "매니저를 삭제합니다.")
+        .addOptions(OptionData(OptionType.USER, "user", "삭제할 유저를 선택하세요.", true))
+
+    override fun run(event: SlashCommandInteractionEvent, bot: JDA) {
+        val manager = event.getOption("user")?.asUser
+
+        if(manager == null) {
+            event.hook.sendMessage("유저는 필수사항입니다.").queue()
+            return
+        }
+        if(manager.idLong == event.user.idLong) {
+            event.hook.sendMessage("자신은 매니저로 설정할 수 없습니다.").queue()
+            return
+        }
+
+        val user = UserService.getUser(event.user.idLong)
+        if(user == null) {
+            event.hook.sendMessage("치지직 계정을 찾을 수 없습니다.").queue()
+            return
+        }
+
+        if(ManagerService.getUser(user.liveAlertGuild ?: 0L, manager.idLong) == null) {
+            event.hook.sendMessage("${manager.name}은 매니저가 아닙니다.")
+        }
+
+        try {
+            ManagerService.deleteManager(user, manager.idLong)
+            event.hook.sendMessage("삭제가 완료되었습니다. ${manager.effectiveName}").queue()
+        } catch (e: Exception) {
+            event.hook.sendMessage("에러가 발생했습니다.").queue()
+            logger.debug(e.stackTraceToString())
+        }
+    }
+}
--- a/chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/discord/commands/UpdateCommand.kt
+++ b/chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/discord/commands/UpdateCommand.kt
@@ -1,16 +1,18 @@
-package space.mori.chzzk_bot.discord.commands
+package space.mori.chzzk_bot.chatbot.discord.commands

 import net.dv8tion.jda.api.JDA
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
 import net.dv8tion.jda.api.interactions.commands.OptionType
 import net.dv8tion.jda.api.interactions.commands.build.Commands
 import net.dv8tion.jda.api.interactions.commands.build.OptionData
+import org.jetbrains.exposed.sql.transactions.transaction
 import org.slf4j.LoggerFactory
-import space.mori.chzzk_bot.chzzk.ChzzkHandler
-import space.mori.chzzk_bot.chzzk.Connector
-import space.mori.chzzk_bot.discord.CommandInterface
-import space.mori.chzzk_bot.services.CommandService
-import space.mori.chzzk_bot.services.UserService
+import space.mori.chzzk_bot.chatbot.chzzk.ChzzkHandler
+import space.mori.chzzk_bot.chatbot.chzzk.Connector
+import space.mori.chzzk_bot.chatbot.discord.CommandInterface
+import space.mori.chzzk_bot.common.services.CommandService
+import space.mori.chzzk_bot.common.services.ManagerService
+import space.mori.chzzk_bot.common.services.UserService

 object UpdateCommand : CommandInterface {
    private val logger = LoggerFactory.getLogger(this::class.java)
@@ -30,15 +32,29 @@ object UpdateCommand : CommandInterface {
            return
        }

-        val user = UserService.getUser(event.user.idLong)
-        if(user == null) {
-            event.hook.sendMessage("치지직 계정을 찾을 수 없습니다.").queue()
+        var user = UserService.getUser(event.user.idLong)
+        val manager = event.guild?.idLong?.let { ManagerService.getUser(it, event.user.idLong) }
+        if(user == null && manager == null) {
+            event.hook.sendMessage("당신은 이 명령어를 사용할 수 없습니다.").queue()
            return
        }
-        val chzzkChannel = Connector.getChannel(user.token)
+
+        if (manager != null) {
+            transaction {
+                user = manager.user
+            }
+            user?.let { ManagerService.updateManager(it, event.user.idLong, event.user.effectiveName) }
+        }
+
+        if (user == null) {
+            event.hook.sendMessage("에러가 발생했습니다.").queue()
+            return
+        }
+
+        val chzzkChannel = Connector.getChannel(user!!.token)

        try {
-            CommandService.updateCommand(user, label, content, failContent ?: "")
+            CommandService.updateCommand(user!!, label, content, failContent ?: "")
            chzzkChannel?.let { ChzzkHandler.reloadCommand(it) }
            event.hook.sendMessage("등록이 완료되었습니다. $label = $content").queue()
        } catch (e: Exception) {
--- a/common/build.gradle.kts
+++ b/common/build.gradle.kts
@@ -0,0 +1,48 @@
+plugins {
+    kotlin("jvm")
+}
+
+group = project.rootProject.group
+version = project.rootProject.version
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    // https://mvnrepository.com/artifact/org.jetbrains.exposed/exposed-core
+    api("org.jetbrains.exposed:exposed-core:0.52.0")
+    // https://mvnrepository.com/artifact/org.jetbrains.exposed/exposed-dao
+    api("org.jetbrains.exposed:exposed-dao:0.52.0")
+    // https://mvnrepository.com/artifact/org.jetbrains.exposed/exposed-jdbc
+    api("org.jetbrains.exposed:exposed-jdbc:0.52.0")
+    // https://mvnrepository.com/artifact/org.jetbrains.exposed/exposed-kotlin-datetime
+    api("org.jetbrains.exposed:exposed-java-time:0.52.0")
+
+    // https://mvnrepository.com/artifact/com.zaxxer/HikariCP
+    api("com.zaxxer:HikariCP:5.1.0")
+
+    // https://mvnrepository.com/artifact/ch.qos.logback/logback-classic
+    implementation("ch.qos.logback:logback-classic:1.5.6")
+
+    // https://mvnrepository.com/artifact/org.mariadb.jdbc/mariadb-java-client
+    implementation("org.mariadb.jdbc:mariadb-java-client:3.4.1")
+
+    // https://mvnrepository.com/artifact/io.github.cdimascio/dotenv-kotlin
+    implementation("io.github.cdimascio:dotenv-kotlin:6.4.1")
+
+    // https://mvnrepository.com/artifact/com.squareup.okhttp3/okhttp
+    implementation("com.squareup.okhttp3:okhttp:4.12.0")
+
+    // https://mvnrepository.com/artifact/com.google.code.gson/gson
+    implementation("com.google.code.gson:gson:2.11.0")
+
+    testImplementation(kotlin("test"))
+}
+
+tasks.test {
+    useJUnitPlatform()
+}
+kotlin {
+    jvmToolchain(21)
+}
--- a/common/src/main/kotlin/space/mori/chzzk_bot/common/Connector.kt
+++ b/common/src/main/kotlin/space/mori/chzzk_bot/common/Connector.kt
@@ -1,11 +1,16 @@
-package space.mori.chzzk_bot
+package space.mori.chzzk_bot.common

 import com.zaxxer.hikari.HikariConfig
 import com.zaxxer.hikari.HikariDataSource
+import io.github.cdimascio.dotenv.dotenv
 import org.jetbrains.exposed.sql.Database
 import org.jetbrains.exposed.sql.SchemaUtils
 import org.jetbrains.exposed.sql.transactions.transaction
-import space.mori.chzzk_bot.models.*
+import space.mori.chzzk_bot.common.models.*
+
+val dotenv = dotenv {
+    ignoreIfMissing = true
+}

 object Connector {
    private val hikariConfig = HikariConfig().apply {
@@ -19,7 +24,18 @@ object Connector {

    init {
        Database.connect(dataSource)
-        val tables = listOf(Users, Commands, Counters, DailyCounters, PersonalCounters)
+        val tables = listOf(
+            Users,
+            Commands,
+            Counters,
+            DailyCounters,
+            PersonalCounters,
+            Managers,
+            TimerConfigs,
+            LiveStatuses,
+            SongLists,
+            SongConfigs
+        )

        transaction {
            SchemaUtils.createMissingTablesAndColumns(* tables.toTypedArray())
--- a/common/src/main/kotlin/space/mori/chzzk_bot/common/events/EventBase.kt
+++ b/common/src/main/kotlin/space/mori/chzzk_bot/common/events/EventBase.kt
@@ -0,0 +1,32 @@
+package space.mori.chzzk_bot.common.events
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.filterIsInstance
+import kotlinx.coroutines.launch
+import kotlin.reflect.KClass
+
+interface Event
+
+interface EventBus {
+    suspend fun <T: Event> post(event: T)
+    fun <T: Event> subscribe(eventClass: KClass<T>, listener: (T) -> Unit)
+}
+
+class CoroutinesEventBus: EventBus {
+    private val _events = MutableSharedFlow<Event>()
+    val events: SharedFlow<Event> get() = _events
+
+    override suspend fun<T: Event> post(event: T) = _events.emit(event)
+
+    override fun <T: Event> subscribe(eventClass: KClass<T>, listener: (T) -> Unit) {
+        CoroutineScope(Dispatchers.Default).launch {
+            events.filterIsInstance(eventClass)
+                .collect {
+                    listener(it)
+                }
+        }
+    }
+}
--- a/common/src/main/kotlin/space/mori/chzzk_bot/common/events/SongEvents.kt
+++ b/common/src/main/kotlin/space/mori/chzzk_bot/common/events/SongEvents.kt
@@ -0,0 +1,22 @@
+package space.mori.chzzk_bot.common.events
+
+enum class SongType(var value: Int) {
+    ADD(0),
+    REMOVE(1),
+    NEXT(2),
+
+    STREAM_OFF(50)
+}
+
+class SongEvent(
+    val uid: String,
+    val type: SongType,
+    val reqUid: String?,
+    val reqName: String?,
+    val name: String?,
+    val author: String?,
+    val time: Int?,
+    val url: String?
+): Event {
+    var TAG = javaClass.simpleName
+}
--- a/common/src/main/kotlin/space/mori/chzzk_bot/common/events/TimerEvents.kt
+++ b/common/src/main/kotlin/space/mori/chzzk_bot/common/events/TimerEvents.kt
@@ -0,0 +1,17 @@
+package space.mori.chzzk_bot.common.events
+
+enum class TimerType(var value: Int) {
+    UPTIME(0),
+    TIMER(1),
+    REMOVE(2),
+
+    STREAM_OFF(50)
+}
+
+class TimerEvent(
+    val uid: String,
+    val type: TimerType,
+    val time: String?
+): Event {
+    var TAG = javaClass.simpleName
+}
--- a/common/src/main/kotlin/space/mori/chzzk_bot/common/models/Command.kt
+++ b/common/src/main/kotlin/space/mori/chzzk_bot/common/models/Command.kt
@@ -1,4 +1,4 @@
-package space.mori.chzzk_bot.models
+package space.mori.chzzk_bot.common.models

 import org.jetbrains.exposed.dao.IntEntity
 import org.jetbrains.exposed.dao.IntEntityClass
--- a/common/src/main/kotlin/space/mori/chzzk_bot/common/models/Counter.kt
+++ b/common/src/main/kotlin/space/mori/chzzk_bot/common/models/Counter.kt
@@ -1,4 +1,4 @@
-package space.mori.chzzk_bot.models
+package space.mori.chzzk_bot.common.models

 import org.jetbrains.exposed.dao.IntEntity
 import org.jetbrains.exposed.dao.IntEntityClass
--- a/common/src/main/kotlin/space/mori/chzzk_bot/common/models/DailyCounters.kt
+++ b/common/src/main/kotlin/space/mori/chzzk_bot/common/models/DailyCounters.kt
@@ -1,4 +1,4 @@
-package space.mori.chzzk_bot.models
+package space.mori.chzzk_bot.common.models

 import org.jetbrains.exposed.dao.IntEntity
 import org.jetbrains.exposed.dao.IntEntityClass
--- a/common/src/main/kotlin/space/mori/chzzk_bot/common/models/LiveStatus.kt
+++ b/common/src/main/kotlin/space/mori/chzzk_bot/common/models/LiveStatus.kt
@@ -0,0 +1,19 @@
+package space.mori.chzzk_bot.common.models
+
+import org.jetbrains.exposed.dao.IntEntity
+import org.jetbrains.exposed.dao.IntEntityClass
+import org.jetbrains.exposed.dao.id.EntityID
+import org.jetbrains.exposed.dao.id.IntIdTable
+import org.jetbrains.exposed.sql.ReferenceOption
+
+object LiveStatuses: IntIdTable("live_statuses") {
+    val user = reference("user", Users, onDelete = ReferenceOption.CASCADE)
+    val status = bool("status")
+}
+
+class LiveStatus(id: EntityID<Int>) : IntEntity(id) {
+    companion object : IntEntityClass<LiveStatus>(LiveStatuses)
+
+    var user by User referencedOn LiveStatuses.user
+    var status by LiveStatuses.status
+}
--- a/common/src/main/kotlin/space/mori/chzzk_bot/common/models/Manager.kt
+++ b/common/src/main/kotlin/space/mori/chzzk_bot/common/models/Manager.kt
@@ -0,0 +1,22 @@
+package space.mori.chzzk_bot.common.models
+
+import org.jetbrains.exposed.dao.IntEntity
+import org.jetbrains.exposed.dao.IntEntityClass
+import org.jetbrains.exposed.dao.id.EntityID
+import org.jetbrains.exposed.dao.id.IntIdTable
+
+object Managers: IntIdTable("manager") {
+    val user = reference("user", Users)
+    val managerId = long("manager_id")
+    val discordGuildId = long("discord_guild_id")
+    var lastUserName = varchar("last_user_name", 255).nullable()
+}
+
+class Manager(id: EntityID<Int>) : IntEntity(id) {
+    companion object : IntEntityClass<Manager>(Managers)
+
+    var user by User referencedOn Managers.user
+    var managerId by Managers.managerId
+    var discordGuildId by Managers.discordGuildId
+    var lastUserName by Managers.lastUserName
+}
--- a/common/src/main/kotlin/space/mori/chzzk_bot/common/models/PersonalCounter.kt
+++ b/common/src/main/kotlin/space/mori/chzzk_bot/common/models/PersonalCounter.kt
@@ -1,4 +1,4 @@
-package space.mori.chzzk_bot.models
+package space.mori.chzzk_bot.common.models

 import org.jetbrains.exposed.dao.IntEntity
 import org.jetbrains.exposed.dao.IntEntityClass
--- a/common/src/main/kotlin/space/mori/chzzk_bot/common/models/SongConfig.kt
+++ b/common/src/main/kotlin/space/mori/chzzk_bot/common/models/SongConfig.kt
@@ -0,0 +1,24 @@
+package space.mori.chzzk_bot.common.models
+
+import org.jetbrains.exposed.dao.IntEntity
+import org.jetbrains.exposed.dao.IntEntityClass
+import org.jetbrains.exposed.dao.id.EntityID
+import org.jetbrains.exposed.dao.id.IntIdTable
+import org.jetbrains.exposed.sql.ReferenceOption
+
+object SongConfigs: IntIdTable("song_config") {
+    val user = reference("user", Users, onDelete = ReferenceOption.CASCADE)
+    val token = varchar("token", 64).nullable()
+    val streamerOnly = bool("streamer_only").default(false)
+    val queueLimit = integer("queue_limit").default(50)
+    val personalLimit = integer("personal_limit").default(5)
+}
+class SongConfig(id: EntityID<Int>) : IntEntity(id) {
+    companion object : IntEntityClass<SongConfig>(SongConfigs)
+
+    var user by User referencedOn SongConfigs.user
+    var token by SongConfigs.token
+    var streamerOnly by SongConfigs.streamerOnly
+    var queueLimit by SongConfigs.queueLimit
+    var personalLimit by SongConfigs.personalLimit
+}
--- a/common/src/main/kotlin/space/mori/chzzk_bot/common/models/SongList.kt
+++ b/common/src/main/kotlin/space/mori/chzzk_bot/common/models/SongList.kt
@@ -0,0 +1,33 @@
+package space.mori.chzzk_bot.common.models
+
+import org.jetbrains.exposed.dao.IntEntity
+import org.jetbrains.exposed.dao.IntEntityClass
+import org.jetbrains.exposed.dao.id.EntityID
+import org.jetbrains.exposed.dao.id.IntIdTable
+import org.jetbrains.exposed.sql.javatime.datetime
+import java.time.LocalDateTime
+
+object SongLists: IntIdTable("song_list") {
+    val user = reference("user", Users)
+    val uid = varchar("uid", 64)
+    val url = varchar("url", 128)
+    val name = text("name")
+    val reqName = varchar("req_name", 20)
+    val author = text("author")
+    val time = integer("time")
+    val created_at = datetime("created_at").default(LocalDateTime.now())
+}
+
+class SongList(id: EntityID<Int>) : IntEntity(id) {
+    companion object : IntEntityClass<SongList>(SongLists)
+
+    var url by SongLists.url
+    var name by SongLists.name
+    var author by SongLists.author
+    var time by SongLists.time
+    var created_at by SongLists.created_at
+
+    var user by User referencedOn SongLists.user
+    var uid by SongLists.uid
+    var reqName by SongLists.reqName
+}
--- a/common/src/main/kotlin/space/mori/chzzk_bot/common/models/TimerConfig.kt
+++ b/common/src/main/kotlin/space/mori/chzzk_bot/common/models/TimerConfig.kt
@@ -0,0 +1,18 @@
+package space.mori.chzzk_bot.common.models
+
+import org.jetbrains.exposed.dao.IntEntity
+import org.jetbrains.exposed.dao.IntEntityClass
+import org.jetbrains.exposed.dao.id.EntityID
+import org.jetbrains.exposed.dao.id.IntIdTable
+import org.jetbrains.exposed.sql.ReferenceOption
+
+object TimerConfigs: IntIdTable("timer_config") {
+    val user = reference("user", Users, onDelete = ReferenceOption.CASCADE)
+    val option = integer("option")
+}
+class TimerConfig(id: EntityID<Int>) : IntEntity(id) {
+    companion object : IntEntityClass<TimerConfig>(TimerConfigs)
+
+    var user by User referencedOn TimerConfigs.user
+    var option by TimerConfigs.option
+}
--- a/common/src/main/kotlin/space/mori/chzzk_bot/common/models/User.kt
+++ b/common/src/main/kotlin/space/mori/chzzk_bot/common/models/User.kt
@@ -1,4 +1,4 @@
-package space.mori.chzzk_bot.models
+package space.mori.chzzk_bot.common.models

 import org.jetbrains.exposed.dao.IntEntity
 import org.jetbrains.exposed.dao.IntEntityClass
--- a/common/src/main/kotlin/space/mori/chzzk_bot/common/services/CommandService.kt
+++ b/common/src/main/kotlin/space/mori/chzzk_bot/common/services/CommandService.kt
@@ -1,17 +1,17 @@
-package space.mori.chzzk_bot.services
+package space.mori.chzzk_bot.common.services

 import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
 import org.jetbrains.exposed.sql.and
 import org.jetbrains.exposed.sql.transactions.transaction
 import org.jetbrains.exposed.sql.update
-import space.mori.chzzk_bot.models.Command
-import space.mori.chzzk_bot.models.Commands
-import space.mori.chzzk_bot.models.User
+import space.mori.chzzk_bot.common.models.Command
+import space.mori.chzzk_bot.common.models.Commands
+import space.mori.chzzk_bot.common.models.User

 object CommandService {
    fun saveCommand(user: User, command: String, content: String, failContent: String): Command {
        return transaction {
-            return@transaction Command.new {
+            Command.new {
                this.user = user
                this.command = command
                this.content = content
--- a/common/src/main/kotlin/space/mori/chzzk_bot/common/services/CounterService.kt
+++ b/common/src/main/kotlin/space/mori/chzzk_bot/common/services/CounterService.kt
@@ -1,8 +1,8 @@
-package space.mori.chzzk_bot.services
+package space.mori.chzzk_bot.common.services

 import org.jetbrains.exposed.sql.and
 import org.jetbrains.exposed.sql.transactions.transaction
-import space.mori.chzzk_bot.models.*
+import space.mori.chzzk_bot.common.models.*
 import java.time.LocalDate

 object CounterService {
@@ -81,8 +81,6 @@ object CounterService {
                (DailyCounters.name eq name) and (DailyCounters.userId eq userId) and (DailyCounters.user eq user.id)
            }.singleOrNull()

-            println("$counter")
-
            if(counter == null) {
                val newCounter = DailyCounter.new {
                    this.name = name
@@ -98,6 +96,7 @@ object CounterService {
                Pair(counter.value, false)
            else {
                counter.value += increment
+                counter.updatedAt = today
                Pair(counter.value, true)
            }
        }
--- a/common/src/main/kotlin/space/mori/chzzk_bot/common/services/LiveStatusService.kt
+++ b/common/src/main/kotlin/space/mori/chzzk_bot/common/services/LiveStatusService.kt
@@ -0,0 +1,30 @@
+package space.mori.chzzk_bot.common.services
+
+import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
+import org.jetbrains.exposed.sql.transactions.transaction
+import space.mori.chzzk_bot.common.models.LiveStatus
+import space.mori.chzzk_bot.common.models.LiveStatuses
+import space.mori.chzzk_bot.common.models.User
+
+object LiveStatusService {
+    fun updateOrCreate(user: User, status: Boolean): LiveStatus {
+        return transaction {
+            return@transaction when(val liveStatus = LiveStatus.find(LiveStatuses.user eq user.id).firstOrNull()) {
+                null -> LiveStatus.new {
+                    this.user = user
+                    this.status = status
+                }
+                else -> {
+                    liveStatus.status = status
+                    liveStatus
+                }
+            }
+        }
+    }
+
+    fun getLiveStatus(user: User): LiveStatus? {
+        return transaction {
+            LiveStatus.find(LiveStatuses.user eq user.id).firstOrNull()
+        }
+    }
+}
--- a/common/src/main/kotlin/space/mori/chzzk_bot/common/services/ManagerService.kt
+++ b/common/src/main/kotlin/space/mori/chzzk_bot/common/services/ManagerService.kt
@@ -0,0 +1,79 @@
+package space.mori.chzzk_bot.common.services
+
+import org.jetbrains.exposed.dao.load
+import org.jetbrains.exposed.dao.with
+import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
+import org.jetbrains.exposed.sql.and
+import org.jetbrains.exposed.sql.transactions.transaction
+import space.mori.chzzk_bot.common.models.Manager
+import space.mori.chzzk_bot.common.models.Managers
+import space.mori.chzzk_bot.common.models.User
+
+object ManagerService {
+    fun saveManager(user: User, discordId: Long, name: String): Manager {
+        if (user.liveAlertGuild == null)
+            throw RuntimeException("${user.username} has no liveAlertGuild")
+
+        return transaction {
+            Manager.new {
+                this.user = user
+                this.discordGuildId = user.liveAlertGuild!!
+                this.managerId = discordId
+                this.lastUserName = name
+            }
+        }
+    }
+
+    fun updateManager(user: User, discordId: Long, name: String): Manager {
+        return transaction {
+            if (user.liveAlertGuild == null)
+                throw RuntimeException("${user.username} has no liveAlertGuild")
+
+            val manager = getUser(user.liveAlertGuild!!, discordId) ?: throw RuntimeException("$name isn't manager.")
+
+            manager.lastUserName = name
+
+            manager
+        }
+    }
+
+    fun getUser(guildId: Long, discordId: Long): Manager? {
+        return transaction {
+            val manager = Manager.find(
+                (Managers.discordGuildId eq guildId) and (Managers.managerId eq discordId),
+            )
+                .with(Manager::user)
+                .firstOrNull()
+            manager
+        }
+    }
+
+    fun getAllUsers(guildId: Long): List<Manager> {
+        return transaction {
+            val result = Manager.find(Managers.discordGuildId eq guildId)
+                .with(Manager::user)
+                .toList()
+
+            result.forEach { it.load(Manager::user) }
+
+            result
+        }
+    }
+
+    fun deleteManager(user: User, discordId: Long): Manager {
+        if (user.liveAlertGuild == null)
+            throw RuntimeException("${user.username} has no liveAlertGuild")
+        return deleteManager(user.liveAlertGuild!!, discordId)
+    }
+
+    fun deleteManager(guildId: Long, discordId: Long): Manager {
+        return transaction {
+            val managerRow = Manager.find((Managers.discordGuildId eq guildId) and (Managers.managerId eq discordId)).firstOrNull()
+
+            managerRow ?: throw RuntimeException("Manager not found! $discordId")
+            managerRow.delete()
+
+            managerRow
+        }
+    }
+}
--- a/common/src/main/kotlin/space/mori/chzzk_bot/common/services/SongConfigService.kt
+++ b/common/src/main/kotlin/space/mori/chzzk_bot/common/services/SongConfigService.kt
@@ -0,0 +1,86 @@
+package space.mori.chzzk_bot.common.services
+
+import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
+import org.jetbrains.exposed.sql.transactions.transaction
+import space.mori.chzzk_bot.common.models.SongConfig
+import space.mori.chzzk_bot.common.models.SongConfigs
+import space.mori.chzzk_bot.common.models.User
+
+object SongConfigService {
+    private fun initConfig(user: User): SongConfig {
+        return transaction {
+            SongConfig.new {
+                this.user = user
+            }
+        }
+    }
+
+    fun getConfig(user: User): SongConfig {
+        return transaction {
+            var songConfig = SongConfig.find(SongConfigs.user eq user.id).firstOrNull()
+            if (songConfig == null) {
+                songConfig = initConfig(user)
+            }
+            songConfig
+        }
+
+    }
+
+    fun getConfig(token: String): SongConfig? {
+        return transaction {
+            SongConfig.find(SongConfigs.token eq token).firstOrNull()
+        }
+    }
+    fun getUserByToken(token: String): User? {
+        return transaction {
+            val songConfig = SongConfig.find(SongConfigs.token eq token).firstOrNull()
+            if(songConfig == null) null
+            else UserService.getUser(songConfig.user.discord)
+        }
+    }
+
+    fun updatePersonalLimit(user: User, limit: Int): SongConfig {
+        return transaction {
+            var songConfig = SongConfig.find(SongConfigs.user eq user.id).firstOrNull()
+            if (songConfig == null) {
+                songConfig = initConfig(user)
+            }
+            songConfig.personalLimit = limit
+            songConfig
+        }
+    }
+    fun updateQueueLimit(user: User, limit: Int): SongConfig {
+        return transaction {
+            var songConfig = SongConfig.find(SongConfigs.user eq user.id).firstOrNull()
+            if (songConfig == null) {
+                songConfig = initConfig(user)
+            }
+            songConfig.queueLimit = limit
+            songConfig
+        }
+    }
+
+    fun updateSession(user: User, token: String?): SongConfig {
+        return transaction {
+            var songConfig = SongConfig.find(SongConfigs.user eq user.id).firstOrNull()
+            if (songConfig == null) {
+                songConfig = initConfig(user)
+            }
+            songConfig.token = token
+
+            songConfig
+        }
+    }
+
+    fun updateStreamerOnly(user: User, config: Boolean): SongConfig {
+        return transaction {
+            var songConfig = SongConfig.find(SongConfigs.user eq user.id).firstOrNull()
+            if (songConfig == null) {
+                songConfig = initConfig(user)
+            }
+            songConfig.streamerOnly = config
+
+            songConfig
+        }
+    }
+}
--- a/common/src/main/kotlin/space/mori/chzzk_bot/common/services/SongListService.kt
+++ b/common/src/main/kotlin/space/mori/chzzk_bot/common/services/SongListService.kt
@@ -0,0 +1,63 @@
+package space.mori.chzzk_bot.common.services
+
+import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
+import org.jetbrains.exposed.sql.and
+import org.jetbrains.exposed.sql.transactions.transaction
+import space.mori.chzzk_bot.common.models.SongList
+import space.mori.chzzk_bot.common.models.SongLists
+import space.mori.chzzk_bot.common.models.User
+
+object SongListService {
+    fun saveSong(user: User, uid: String, url: String, name: String, author: String, time: Int, reqName: String) {
+        return transaction {
+            SongList.new {
+                this.user = user
+                this.uid = uid
+                this.url = url
+                this.name = name
+                this.author = author
+                this.time = time
+                this.reqName = reqName
+            }
+        }
+    }
+
+    fun getSong(user: User, uid: String): List<SongList> {
+        return transaction {
+            SongList.find(
+                (SongLists.user eq user.id) and
+                    (SongLists.uid eq uid)
+            ).toList()
+        }
+    }
+
+    fun getSong(user: User): List<SongList> {
+        return transaction {
+            SongList.find(SongLists.user eq user.id).toList().sortedBy { it.created_at }
+        }
+    }
+
+    fun deleteSong(user: User, uid: String, name: String): SongList {
+        return transaction {
+            val songRow = SongList.find(
+                (SongLists.user eq user.id) and
+                    (SongLists.uid eq uid) and
+                    (SongLists.name eq name)
+            ).firstOrNull()
+
+            songRow ?: throw RuntimeException("Song not found! ${user.username} / $uid / $name")
+
+            songRow.delete()
+            songRow
+        }
+    }
+
+    fun deleteUser(user: User): Boolean {
+        return transaction {
+            val songRow = SongList.find(SongLists.user eq user.id).toList()
+
+            songRow.forEach { it.delete() }
+            true
+        }
+    }
+}
--- a/common/src/main/kotlin/space/mori/chzzk_bot/common/services/TimerConfigService.kt
+++ b/common/src/main/kotlin/space/mori/chzzk_bot/common/services/TimerConfigService.kt
@@ -0,0 +1,48 @@
+package space.mori.chzzk_bot.common.services
+
+import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
+import org.jetbrains.exposed.sql.transactions.transaction
+import org.jetbrains.exposed.sql.update
+import space.mori.chzzk_bot.common.events.TimerType
+import space.mori.chzzk_bot.common.models.TimerConfig
+import space.mori.chzzk_bot.common.models.TimerConfigs
+import space.mori.chzzk_bot.common.models.User
+
+object TimerConfigService {
+    fun saveConfig(user: User, timerConfig: TimerType) {
+        return transaction {
+            TimerConfig.new {
+                this.user = user
+                this.option = timerConfig.value
+            }
+        }
+    }
+
+    fun updateConfig(user: User, timerConfig: TimerType) {
+        return transaction {
+            val updated = TimerConfigs.update({
+                TimerConfigs.user eq user.id
+            }) {
+                it[option] = timerConfig.value
+            }
+
+            if (updated == 0) throw RuntimeException("TimerConfig not found! ${user.username}")
+
+            TimerConfig.find { TimerConfigs.user eq user.id }.first()
+        }
+    }
+
+    fun getConfig(user: User): TimerConfig? {
+        return transaction {
+            TimerConfig.find(TimerConfigs.user eq user.id).firstOrNull()
+        }
+    }
+
+    fun saveOrUpdateConfig(user: User, timerConfig: TimerType) {
+        return if (getConfig(user) == null) {
+            saveConfig(user, timerConfig)
+        } else {
+            updateConfig(user, timerConfig)
+        }
+    }
+}
--- a/common/src/main/kotlin/space/mori/chzzk_bot/common/services/UserService.kt
+++ b/common/src/main/kotlin/space/mori/chzzk_bot/common/services/UserService.kt
@@ -1,10 +1,10 @@
-package space.mori.chzzk_bot.services
+package space.mori.chzzk_bot.common.services

 import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
 import org.jetbrains.exposed.sql.transactions.transaction
 import org.jetbrains.exposed.sql.update
-import space.mori.chzzk_bot.models.User
-import space.mori.chzzk_bot.models.Users
+import space.mori.chzzk_bot.common.models.User
+import space.mori.chzzk_bot.common.models.Users

 object UserService {
    fun saveUser(username: String, token: String, discordID: Long): User {
@@ -39,6 +39,14 @@ object UserService {
        }
    }

+    fun getUserWithGuildId(discordGuildId: Long): User? {
+        return transaction {
+            val users = User.find(Users.liveAlertGuild eq discordGuildId)
+
+            users.firstOrNull()
+        }
+    }
+
    fun getAllUsers(): List<User> {
        return transaction {
            User.all().toList()
--- a/common/src/main/kotlin/space/mori/chzzk_bot/common/utils/ChzzkApis.kt
+++ b/common/src/main/kotlin/space/mori/chzzk_bot/common/utils/ChzzkApis.kt
@@ -1,4 +1,4 @@
-package space.mori.chzzk_bot.chzzk
+package space.mori.chzzk_bot.common.utils

 import com.google.gson.Gson
 import com.google.gson.reflect.TypeToken
@@ -21,12 +21,17 @@ data class IFollowContent(
    val badge: Badge? = null,
    val title: Title? = null,
    val verifiedMark: Boolean = false,
-    val activityBadges: List<String> = emptyList(),
+    val activityBadges: List<Badge> = emptyList(),
    val streamingProperty: StreamingProperty = StreamingProperty()
 )

 data class Badge(
-    val imageUrl: String = ""
+    val badgeNo: Int?,
+    val badgeId: String?,
+    val imageUrl: String?,
+    val title: String?,
+    val description: String?,
+    val activated: Boolean?
 )

 data class Title(
@@ -103,7 +108,7 @@ val client = OkHttpClient.Builder()
    .build()
 val gson = Gson()

-fun getFollowDate(chatID: String, userId: String) : IData<IFollowContent> {
+fun getFollowDate(chatID: String, userId: String) : IData<IFollowContent?> {
    val url = "https://comm-api.game.naver.com/nng_main/v1/chats/$chatID/users/$userId/profile-card?chatType=STREAMING"
    val request = Request.Builder()
        .url(url)
@@ -113,17 +118,18 @@ fun getFollowDate(chatID: String, userId: String) : IData<IFollowContent> {
        try {
            if(!response.isSuccessful) throw IOException("Unexpected code ${response.code}")
            val body = response.body?.string()
-            val follow = gson.fromJson(body, object: TypeToken<IData<IFollowContent>>() {})
+            val follow = gson.fromJson(body, object: TypeToken<IData<IFollowContent?>>() {})

            return follow
        } catch(e: Exception) {
+            println(e.stackTrace)
            throw e
        }
    }
 }

-fun getStreamInfo(userId: String) : IData<IStreamInfo> {
-    val url = "https://api.chzzk.naver.com/service/v2/channels/${userId}/live-detail"
+fun getStreamInfo(userId: String) : IData<IStreamInfo?> {
+    val url = "https://api.chzzk.naver.com/service/v3/channels/${userId}/live-detail"
    val request = Request.Builder()
        .url(url)
        .build()
@@ -132,7 +138,7 @@ fun getStreamInfo(userId: String) : IData<IStreamInfo> {
        try {
            if(!response.isSuccessful) throw IOException("Unexpected code ${response.code}")
            val body = response.body?.string()
-            val follow = gson.fromJson(body, object: TypeToken<IData<IStreamInfo>>() {})
+            val follow = gson.fromJson(body, object: TypeToken<IData<IStreamInfo?>>() {})

            return follow
        } catch(e: Exception) {
--- a/common/src/main/kotlin/space/mori/chzzk_bot/common/utils/convertChzzkDateToLocalDateTime.kt
+++ b/common/src/main/kotlin/space/mori/chzzk_bot/common/utils/convertChzzkDateToLocalDateTime.kt
@@ -0,0 +1,20 @@
+package space.mori.chzzk_bot.common.utils
+
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
+import java.time.LocalDateTime
+import java.time.format.DateTimeFormatter
+import java.time.format.DateTimeParseException
+
+val logger: Logger = LoggerFactory.getLogger("convertChzzkDateToLocalDateTime")
+
+fun convertChzzkDateToLocalDateTime(chzzkDate: String): LocalDateTime? {
+    val formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")
+
+    return try {
+        LocalDateTime.parse(chzzkDate, formatter)
+    } catch(e: DateTimeParseException) {
+        logger.debug("Error to parsing date", e)
+        null
+    }
+}
--- a/common/src/main/kotlin/space/mori/chzzk_bot/common/utils/getRandomString.kt
+++ b/common/src/main/kotlin/space/mori/chzzk_bot/common/utils/getRandomString.kt
@@ -0,0 +1,9 @@
+package space.mori.chzzk_bot.common.utils
+
+fun getRandomString(length: Int): String {
+    val charPool = ('a'..'z') + ('0'..'9')
+    return (1..length)
+        .map { kotlin.random.Random.nextInt(0, charPool.size) }
+        .map(charPool::get)
+        .joinToString("")
+}
--- a/common/src/main/kotlin/space/mori/chzzk_bot/common/utils/getUptime.kt
+++ b/common/src/main/kotlin/space/mori/chzzk_bot/common/utils/getUptime.kt
@@ -0,0 +1,14 @@
+package space.mori.chzzk_bot.common.utils
+
+import java.time.LocalDateTime
+import java.time.temporal.ChronoUnit
+
+fun getUptime(streamOnTime: LocalDateTime): String {
+    val currentTime = LocalDateTime.now()
+
+    val hours = ChronoUnit.HOURS.between(streamOnTime, currentTime)
+    val minutes = ChronoUnit.MINUTES.between(streamOnTime?.plusHours(hours), currentTime)
+    val seconds = ChronoUnit.SECONDS.between(streamOnTime?.plusHours(hours)?.plusMinutes(minutes), currentTime)
+
+    return String.format("%02d:%02d:%02d", hours, minutes, seconds)
+}
--- a/common/src/main/kotlin/space/mori/chzzk_bot/common/utils/getYoutube.kt
+++ b/common/src/main/kotlin/space/mori/chzzk_bot/common/utils/getYoutube.kt
@@ -0,0 +1,115 @@
+package space.mori.chzzk_bot.common.utils
+
+import com.google.gson.JsonObject
+import io.github.cdimascio.dotenv.dotenv
+import okhttp3.HttpUrl
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import java.io.IOException
+import java.net.URLEncoder
+
+data class YoutubeVideo(
+    val url: String,
+    val name: String,
+    val author: String,
+    val length: Int
+)
+
+val regex = ".*(?:youtu.be/|v/|u/\\w/|embed/|watch\\?v=|&v=)([^#&?]*).*".toRegex()
+val durationRegex = """PT(\d+H)?(\d+M)?(\d+S)?""".toRegex()
+
+val dotenv = dotenv {
+    ignoreIfMissing = true
+}
+
+fun searchYoutube(query: String): String? {
+    val url = "https://youtube-search-results.p.rapidapi.com/youtube-search/?q=${URLEncoder.encode(query, "UTF-8")}"
+    val request = Request.Builder()
+        .url(url)
+        .addHeader("x-rapidapi-host", "youtube-search-results.p.rapidapi.com")
+        .addHeader("x-rapidapi-key", dotenv["RAPID_KEY"] ?: "")
+        .build()
+
+    OkHttpClient().newCall(request).execute().use { response ->
+        if (!response.isSuccessful) throw IOException("Unexpected code $response")
+
+        val responseBody = response.body?.string()
+        val json = gson.fromJson(responseBody, JsonObject::class.java)
+
+        val videos = json.getAsJsonArray("videos")
+
+        val firstVideo = videos.get(0).asJsonObject
+
+        val videoId = firstVideo.get("id").asString
+
+        return videoId
+    }
+}
+
+fun getYoutubeVideoId(query: String): String? {
+    val matchResult = regex.find(query)
+
+    return if(matchResult == null) {
+        searchYoutube(query)
+    } else {
+        matchResult.groups[1]?.value
+    }
+}
+
+fun parseDuration(duration: String): Int {
+    val matchResult = durationRegex.find(duration)
+    val (hours, minutes, seconds) = matchResult?.destructured ?: return 0
+
+    val hourInSec = hours.dropLast(1).toIntOrNull()?.times(3600) ?: 0
+    val minutesInSec = minutes.dropLast(1).toIntOrNull()?.times(60) ?: 0
+    val totalSeconds = seconds.dropLast(1).toIntOrNull() ?: 0
+
+    return hourInSec + minutesInSec + totalSeconds
+}
+
+fun getYoutubeVideo(query: String): YoutubeVideo? {
+    val videoId = getYoutubeVideoId(query)
+
+    val api = HttpUrl.Builder()
+        .scheme("https")
+        .host("www.googleapis.com")
+        .addPathSegment("youtube")
+        .addPathSegment("v3")
+        .addPathSegment("videos")
+        .addQueryParameter("id", videoId)
+        .addQueryParameter("key", dotenv["YOUTUBE_API_KEY"])
+        .addQueryParameter("part", "snippet,contentDetails,status")
+        .build()
+
+
+    val request = Request.Builder()
+        .url(api)
+        .build()
+
+    client.newCall(request).execute().use { response ->
+        if (!response.isSuccessful) throw IOException("Unexpected code $response")
+
+        val responseBody = response.body?.string()
+        val json = gson.fromJson(responseBody, JsonObject::class.java)
+        val items = json.getAsJsonArray("items")
+
+        if (items == null || items.size() == 0) return null
+
+        val item = items[0].asJsonObject
+        val snippet = item.getAsJsonObject("snippet")
+        val contentDetail = item.getAsJsonObject("contentDetails")
+        val status = item.getAsJsonObject("status")
+
+        if (!status.get("embeddable").asBoolean) return null
+
+        val duration = contentDetail.get("duration").asString
+        val length = parseDuration(duration)
+
+        return YoutubeVideo(
+            "https://www.youtube.com/watch?v=$videoId",
+            snippet.get("title").asString,
+            snippet.get("channelTitle").asString,
+            length
+        )
+    }
+}
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,6 +1,6 @@
 kotlin.code.style=official
 group = space.mori
-version = 1.0.0
+version = 1.2.0

 org.gradle.jvmargs=-Dfile.encoding=UTF-8
 org.gradle.console=plain
--- a/inc.env
+++ b/inc.env
@@ -4,5 +4,7 @@ DB_URL=jdbc:mariadb://localhost:3306/chzzk
 DB_USER=chzzk
 DB_PASS=chzzk
 RUN_AGENT=false
+YOUTUBE_API_KEY=
+RAPID_KEY=
 NID_AUT=
 NID_SES=
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -14,6 +14,13 @@ pluginManagement {
        mavenCentral()
        gradlePluginPortal()
        maven { url = uri("https://maven.covers1624.net") }
-        maven { url = uri("https://repo.spring.io/plugins-release/") }
+        maven { url = uri("https://jitpack.io") }
+
    }
 }
+plugins {
+    id("org.gradle.toolchains.foojay-resolver-convention") version "0.8.0"
+}
+include("common")
+include("chatbot")
+include("webserver")
--- a/src/main/kotlin/space/mori/chzzk_bot/Main.kt
+++ b/src/main/kotlin/space/mori/chzzk_bot/Main.kt
@@ -3,11 +3,17 @@ package space.mori.chzzk_bot
 import io.github.cdimascio.dotenv.dotenv
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.runBlocking
+import org.koin.core.context.GlobalContext.startKoin
+import org.koin.dsl.module
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
-import space.mori.chzzk_bot.chzzk.ChzzkHandler
-import space.mori.chzzk_bot.discord.Discord
-import space.mori.chzzk_bot.chzzk.Connector as ChzzkConnector
+import space.mori.chzzk_bot.chatbot.chzzk.ChzzkHandler
+import space.mori.chzzk_bot.chatbot.discord.Discord
+import space.mori.chzzk_bot.chatbot.chzzk.Connector as ChzzkConnector
+import space.mori.chzzk_bot.common.Connector
+import space.mori.chzzk_bot.common.events.CoroutinesEventBus
+import space.mori.chzzk_bot.webserver.start
+import space.mori.chzzk_bot.webserver.stop
 import java.util.concurrent.TimeUnit
 import kotlin.system.exitProcess

@@ -16,16 +22,24 @@ val dotenv = dotenv {
 }
 val logger: Logger = LoggerFactory.getLogger("main")

-val discord = Discord()
-
-val connector = Connector
-val chzzkConnector = ChzzkConnector
-val chzzkHandler = ChzzkHandler
-
 fun main(args: Array<String>) {
+    val dispatcher = module {
+        single { CoroutinesEventBus() }
+    }
+    startKoin {
+        modules(dispatcher)
+    }
+
+    val discord = Discord()
+
+    val connector = Connector
+    val chzzkConnector = ChzzkConnector
+    val chzzkHandler = ChzzkHandler
+
    discord.enable()
    chzzkHandler.enable()
    chzzkHandler.runStreamInfo()
+    start()

    if(dotenv.get("RUN_AGENT", "false").toBoolean()) {
        runBlocking {
@@ -36,6 +50,8 @@ fun main(args: Array<String>) {

    Runtime.getRuntime().addShutdownHook(Thread {
        logger.info("Shutting down...")
+        stop()
+
        chzzkHandler.stopStreamInfo()
        chzzkHandler.disable()
        discord.disable()
--- a/src/main/kotlin/space/mori/chzzk_bot/chzzk/MessageHandler.kt
+++ b/src/main/kotlin/space/mori/chzzk_bot/chzzk/MessageHandler.kt
@@ -1,174 +0,0 @@
-package space.mori.chzzk_bot.chzzk
-
-import org.slf4j.Logger
-import space.mori.chzzk_bot.models.User
-import space.mori.chzzk_bot.services.CommandService
-import space.mori.chzzk_bot.services.CounterService
-import space.mori.chzzk_bot.services.UserService
-import xyz.r2turntrue.chzzk4j.chat.ChatMessage
-import xyz.r2turntrue.chzzk4j.chat.ChzzkChat
-import xyz.r2turntrue.chzzk4j.types.channel.ChzzkChannel
-import java.text.SimpleDateFormat
-import java.time.LocalDate
-import java.time.Period
-import java.time.format.DateTimeFormatter
-import java.util.*
-
-
-class MessageHandler(
-    private val channel: ChzzkChannel,
-    private val logger: Logger,
-    private val listener: ChzzkChat
-) {
-    private val commands = mutableMapOf<String, (msg: ChatMessage, user: User) -> Unit>()
-
-    private val counterPattern = Regex("<counter:([^>]+)>")
-    private val personalCounterPattern = Regex("<counter_personal:([^>]+)>")
-    private val dailyCounterPattern = Regex("<daily_counter:([^>]+)>")
-    private val namePattern = Regex("<name>")
-    private val followPattern = Regex("<following>")
-
-    init {
-        reloadCommand()
-    }
-
-    internal fun reloadCommand() {
-        val user = UserService.getUser(channel.channelId)
-            ?: throw RuntimeException("User not found. it's bug? ${channel.channelName} - ${channel.channelId}")
-        val commands = CommandService.getCommands(user)
-        val manageCommands = mapOf("!명령어추가" to this::manageAddCommand, "!명령어삭제" to this::manageRemoveCommand, "!명령어수정" to this::manageUpdateCommand)
-
-        manageCommands.forEach { (commandName, command) ->
-            this.commands[commandName] = command
-        }
-
-        commands.map {
-            this.commands.put(it.command.lowercase()) { msg, user ->
-                logger.debug("${channel.channelName} - ${it.command} - ${it.content}/${it.failContent}")
-
-                val result = replaceCounters(Pair(it.content, it.failContent), user, msg, listener, msg.profile?.nickname ?: "")
-                listener.sendChat(result)
-            }
-        }
-    }
-
-    private fun manageAddCommand(msg: ChatMessage, user: User) {
-        if (msg.profile?.userRoleCode == "common_user") {
-            listener.sendChat("매니저만 명령어를 추가할 수 있습니다.")
-            return
-        }
-
-        val parts = msg.content.split(" ", limit = 3)
-        if (parts.size < 3) {
-            listener.sendChat("명령어 추가 형식은 '!명령어추가 명령어 내용'입니다.")
-            return
-        }
-        if (commands.containsKey(parts[1])) {
-            listener.sendChat("${parts[1]} 명령어는 이미 있는 명령어입니다.")
-            return
-        }
-        val command = parts[1]
-        val content = parts[2]
-        CommandService.saveCommand(user, command, content, "")
-        listener.sendChat("명령어 '$command' 추가되었습니다.")
-    }
-
-    private fun manageUpdateCommand(msg: ChatMessage, user: User) {
-        if (msg.profile?.userRoleCode == "common_user") {
-            listener.sendChat("매니저만 명령어를 추가할 수 있습니다.")
-            return
-        }
-
-        val parts = msg.content.split(" ", limit = 3)
-        if (parts.size < 3) {
-            listener.sendChat("명령어 수정 형식은 '!명령어수정 명령어 내용'입니다.")
-            return
-        }
-        if (!commands.containsKey(parts[1])) {
-            listener.sendChat("${parts[1]} 명령어는 없는 명령어입니다.")
-            return
-        }
-        val command = parts[1]
-        val content = parts[2]
-        CommandService.updateCommand(user, command, content, "")
-        listener.sendChat("명령어 '$command' 수정되었습니다.")
-    }
-
-    private fun manageRemoveCommand(msg: ChatMessage, user: User) {
-        if (msg.profile?.userRoleCode == "common_user") {
-            listener.sendChat("매니저만 명령어를 삭제할 수 있습니다.")
-            return
-        }
-
-        val parts = msg.content.split(" ", limit = 2)
-        if (parts.size < 2) {
-            listener.sendChat("명령어 삭제 형식은 '!명령어삭제 명령어'입니다.")
-            return
-        }
-        val command = parts[1]
-        CommandService.removeCommand(user, command)
-        listener.sendChat("명령어 '$command' 삭제되었습니다.")
-    }
-
-    internal fun handle(msg: ChatMessage, user: User) {
-        val commandKey = msg.content.split(' ')[0]
-
-        commands[commandKey.lowercase()]?.let { it(msg, user) }
-    }
-
-    private fun replaceCounters(chat: Pair<String, String>, user: User, msg: ChatMessage, listener: ChzzkChat, userName: String): String {
-        var result = chat.first
-        var isFail = false
-
-        result = dailyCounterPattern.replace(result) {
-            val name = it.groupValues[1]
-            val dailyCounter = CounterService.getDailyCounterValue(name, msg.userId, user)
-
-            return@replace if(dailyCounter.second)
-                CounterService.updateDailyCounterValue(name, msg.userId, 1, user).first.toString()
-            else {
-                isFail = true
-                dailyCounter.first.toString()
-            }
-        }
-
-        if(isFail && chat.second != "") {
-            result = chat.second
-            result = dailyCounterPattern.replace(result) {
-                val name = it.groupValues[1]
-                val dailyCounter = CounterService.getDailyCounterValue(name, msg.userId, user)
-
-                dailyCounter.first.toString()
-            }
-        }
-
-        result = followPattern.replace(result) {
-            val following = getFollowDate(listener.chatId, msg.userId)
-            val dateString: String = following.content.streamingProperty.following?.followDate ?: SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(
-                Date()
-            )
-            val today = LocalDate.now()
-
-            val formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")
-            // 문자열을 LocalDate 객체로 변환
-            val pastDate = LocalDate.parse(dateString, formatter)
-
-            val period = Period.between(pastDate, today)
-            period.days.toString()
-        }
-
-        result = counterPattern.replace(result) {
-            val name = it.groupValues[1]
-            CounterService.updateCounterValue(name, 1, user).toString()
-        }
-
-        result = personalCounterPattern.replace(result) {
-            val name = it.groupValues[1]
-            CounterService.updatePersonalCounterValue(name, msg.userId, 1, user).toString()
-        }
-
-        result = namePattern.replace(result, userName)
-
-        return result
-    }
-}
--- a/src/main/kotlin/space/mori/chzzk_bot/discord/Discord.kt
+++ b/src/main/kotlin/space/mori/chzzk_bot/discord/Discord.kt
@@ -1,76 +0,0 @@
-package space.mori.chzzk_bot.discord
-
-import net.dv8tion.jda.api.JDA
-import net.dv8tion.jda.api.JDABuilder
-import net.dv8tion.jda.api.entities.Activity
-import net.dv8tion.jda.api.entities.Guild
-import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
-import net.dv8tion.jda.api.hooks.ListenerAdapter
-import space.mori.chzzk_bot.dotenv
-import org.slf4j.LoggerFactory
-import space.mori.chzzk_bot.discord.commands.*
-
-class Discord: ListenerAdapter() {
-    private lateinit var bot: JDA
-    private var guild: Guild? = null
-    private val logger = LoggerFactory.getLogger(this::class.java)
-
-    private val commands = listOf(
-        AddCommand,
-        AlertCommand,
-        PingCommand,
-        RegisterCommand,
-        RemoveCommand,
-        UpdateCommand,
-    )
-
-    override fun onSlashCommandInteraction(event: SlashCommandInteractionEvent) {
-        event.deferReply().queue()
-        val handler = commands.find { it.name == event.name }
-        logger.debug("Handler: ${handler?.name ?: "undefined"} command")
-        handler?.run(event, bot)
-    }
-
-    internal fun enable() {
-        val thread = Thread {
-            try {
-                bot = JDABuilder.createDefault(dotenv["DISCORD_TOKEN"])
-                    .setActivity(Activity.playing("치지직 보는중"))
-                    .addEventListeners(this)
-                    .build().awaitReady()
-
-                guild = bot.getGuildById(dotenv["GUILD_ID"])
-
-                bot.updateCommands()
-                    .addCommands(* commands.map { it.command }.toTypedArray())
-                    .onSuccess {
-                        logger.info("Command update success!")
-                        logger.debug("Command list: ${commands.joinToString("/ ") { it.name }}")
-                    }
-                    .queue()
-
-
-                if (guild == null) {
-                    logger.info("No guild found!")
-                    this.disable()
-                }
-            } catch (e: Exception) {
-                logger.info("Could not enable Discord!")
-                logger.debug(e.stackTraceToString())
-            }
-        }
-        thread.start()
-    }
-
-    internal fun disable() {
-        try {
-            bot.shutdown()
-        } catch(e: Exception) {
-            logger.info("Error while shutting down Discord!")
-            logger.debug(e.stackTraceToString())
-        }
-    }
-
-    internal fun getChannel(guildId: Long, channelId: Long) =
-        bot.getGuildById(guildId)?.getTextChannelById(channelId)
-}
--- a/src/main/kotlin/space/mori/chzzk_bot/discord/commands/AlertCommand.kt
+++ b/src/main/kotlin/space/mori/chzzk_bot/discord/commands/AlertCommand.kt
@@ -1,44 +0,0 @@
-package space.mori.chzzk_bot.discord.commands
-
-import net.dv8tion.jda.api.JDA
-import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
-import net.dv8tion.jda.api.interactions.commands.OptionType
-import net.dv8tion.jda.api.interactions.commands.build.Commands
-import net.dv8tion.jda.api.interactions.commands.build.OptionData
-import org.slf4j.LoggerFactory
-import space.mori.chzzk_bot.chzzk.ChzzkHandler
-import space.mori.chzzk_bot.chzzk.Connector
-import space.mori.chzzk_bot.discord.CommandInterface
-import space.mori.chzzk_bot.services.UserService
-
-object AlertCommand : CommandInterface {
-    private val logger = LoggerFactory.getLogger(this::class.java)
-    override val name: String = "alert"
-    override val command = Commands.slash(name, "명령어를 추가합니다.")
-        .addOptions(OptionData(OptionType.CHANNEL, "channel", "알림을 보낼 채널을 입력하세요."))
-        .addOptions(OptionData(OptionType.STRING, "content", "표시될 텍스트를 입력하세요. 비워두면 알람이 취소됩니다."))
-
-    override fun run(event: SlashCommandInteractionEvent, bot: JDA) {
-        val channel = event.getOption("channel")?.asChannel
-        val content = event.getOption("content")?.asString
-
-        val user = UserService.getUser(event.user.idLong)
-        if(user == null) {
-            event.hook.sendMessage("치지직 계정을 찾을 수 없습니다.").queue()
-            return
-        }
-
-        val chzzkChannel = Connector.getChannel(user.token)
-
-        try {
-            val newUser = UserService.updateLiveAlert(user.id.value, channel?.guild?.idLong ?: 0L, channel?.idLong ?: 0L, content ?: "")
-            try {
-                ChzzkHandler.reloadUser(chzzkChannel!!, newUser)
-            } catch (_: Exception) {}
-            event.hook.sendMessage("업데이트가 완료되었습니다.").queue()
-        } catch (e: Exception) {
-            event.hook.sendMessage("에러가 발생했습니다.").queue()
-            logger.debug(e.stackTraceToString())
-        }
-    }
-}
--- a/src/main/resources/logback-debug.xml
+++ b/src/main/resources/logback-debug.xml
@@ -0,0 +1,35 @@
+<configuration>
+
+    <!-- 콘솔에 출력하는 기본 로그 설정 -->
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+            <level>DEBUG</level>
+        </filter>
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
+        </encoder>
+    </appender>
+
+    <!-- HikariCP 로그 레벨 설정 -->
+    <logger name="com.zaxxer.hikari" level="INFO" />
+    <logger name="o.m.jdbc.client.impl.StandardClient" level="INFO" />
+    <logger name="o.m.jdbc.message.server.OkPacket" level="INFO" />
+    <logger name="o.m.jdbc.client.impl.StandardClient" level="INFO" />
+
+    <logger name="com.zaxxer.hikari.HikariConfig" level="WARN" />
+    <logger name="com.zaxxer.hikari.pool.PoolBase" level="WARN" />
+    <logger name="com.zaxxer.hikari.pool.HikariPool" level="WARN" />
+    <logger name="com.zaxxer.hikari.util.DriverDataSource" level="WARN" />
+
+    <!-- Exposed 로그 레벨 설정 -->
+    <logger name="org.jetbrains.exposed" level="INFO" />
+    <logger name="Exposed" level="INFO" />
+    <logger name="org.jetbrains.exposed.sql" level="WARN" />
+    <logger name="org.jetbrains.exposed.sql.transactions" level="WARN" />
+
+    <!-- 루트 로거 설정 -->
+    <root level="DEBUG">
+        <appender-ref ref="STDOUT" />
+    </root>
+
+</configuration>
--- a/src/main/resources/logback.xml
+++ b/src/main/resources/logback.xml
@@ -3,7 +3,7 @@
    <!-- 콘솔에 출력하는 기본 로그 설정 -->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
-            <level>DEBUG</level>
+            <level>INFO</level>
        </filter>
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
--- a/webserver/build.gradle.kts
+++ b/webserver/build.gradle.kts
@@ -0,0 +1,48 @@
+plugins {
+    kotlin("jvm")
+    kotlin("plugin.serialization").version("2.0.0")
+}
+
+group = project.rootProject.group
+version = project.rootProject.version
+
+repositories {
+    mavenCentral()
+}
+
+val ktorVersion = "2.3.12"
+
+dependencies {
+    implementation("io.ktor:ktor-server-core:$ktorVersion")
+    implementation("io.ktor:ktor-server-netty:$ktorVersion")
+    implementation("io.ktor:ktor-server-websockets:$ktorVersion")
+    implementation("io.ktor:ktor-server-swagger:$ktorVersion")
+    implementation("io.ktor:ktor-server-content-negotiation:$ktorVersion")
+    implementation("io.ktor:ktor-serialization-kotlinx-json:$ktorVersion")
+    implementation("io.ktor:ktor-server-cors:$ktorVersion")
+    implementation("io.ktor:ktor-server-swagger:$ktorVersion")
+
+    implementation("io.swagger.codegen.v3:swagger-codegen-generators:1.0.50")
+
+    // https://mvnrepository.com/artifact/org.jetbrains.kotlinx/kotlinx-coroutines-core
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0-RC")
+    // https://mvnrepository.com/artifact/org.jetbrains.kotlin/kotlin-reflect
+    implementation("org.jetbrains.kotlin:kotlin-reflect:2.0.0")
+
+    // https://mvnrepository.com/artifact/io.insert-koin/koin-core
+    implementation("io.insert-koin:koin-core:4.0.0-RC1")
+
+    // https://mvnrepository.com/artifact/ch.qos.logback/logback-classic
+    implementation("ch.qos.logback:logback-classic:1.5.6")
+
+    implementation(project(":common"))
+
+    testImplementation(kotlin("test"))
+}
+
+tasks.test {
+    useJUnitPlatform()
+}
+kotlin {
+    jvmToolchain(21)
+}
--- a/webserver/src/main/kotlin/space/mori/chzzk_bot/webserver/Main.kt
+++ b/webserver/src/main/kotlin/space/mori/chzzk_bot/webserver/Main.kt
@@ -0,0 +1,57 @@
+package space.mori.chzzk_bot.webserver
+
+import io.ktor.http.*
+import io.ktor.serialization.kotlinx.*
+import io.ktor.serialization.kotlinx.json.*
+import io.ktor.server.application.*
+import io.ktor.server.engine.*
+import io.ktor.server.netty.*
+import io.ktor.server.plugins.contentnegotiation.*
+import io.ktor.server.plugins.cors.routing.*
+import io.ktor.server.plugins.swagger.*
+import io.ktor.server.routing.*
+import io.ktor.server.websocket.*
+import kotlinx.serialization.json.Json
+import space.mori.chzzk_bot.webserver.routes.*
+import java.time.Duration
+
+val server = embeddedServer(Netty, port = 8080) {
+    install(WebSockets) {
+        pingPeriod = Duration.ofSeconds(15)
+        timeout = Duration.ofSeconds(15)
+        maxFrameSize = Long.MAX_VALUE
+        masking = false
+        contentConverter = KotlinxWebsocketSerializationConverter(Json)
+    }
+
+    install(ContentNegotiation) {
+        json(Json {
+            prettyPrint = true
+            isLenient = true
+        })
+    }
+    install(CORS) {
+        anyHost()
+        allowHeader(HttpHeaders.ContentType)
+    }
+    routing {
+        apiRoutes()
+        apiSongRoutes()
+        wsTimerRoutes()
+        wsSongRoutes()
+        wsSongListRoutes()
+        swaggerUI("swagger-ui/index.html", "openapi/documentation.yaml") {
+            options {
+                version = "1.2.0"
+            }
+        }
+    }
+}
+
+fun start() {
+    server.start(wait = true)
+}
+
+fun stop() {
+    server.stop()
+}
--- a/webserver/src/main/kotlin/space/mori/chzzk_bot/webserver/routes/ApiRoutes.kt
+++ b/webserver/src/main/kotlin/space/mori/chzzk_bot/webserver/routes/ApiRoutes.kt
@@ -0,0 +1,100 @@
+package space.mori.chzzk_bot.webserver.routes
+
+import io.ktor.http.*
+import io.ktor.server.application.*
+import io.ktor.server.response.*
+import io.ktor.server.routing.*
+import kotlinx.serialization.Serializable
+import space.mori.chzzk_bot.common.services.SongConfigService
+import space.mori.chzzk_bot.common.utils.getStreamInfo
+
+@Serializable
+data class GetUserDTO(
+    val uid: String,
+    val nickname: String,
+    val isStreamOn: Boolean,
+    val avatarUrl: String
+)
+
+@Serializable
+data class GetSessionDTO(
+    val uid: String,
+    val nickname: String,
+    val isStreamOn: Boolean,
+    val avatarUrl: String,
+    val maxQueueSize: Int,
+    val maxUserSize: Int,
+    val isStreamerOnly: Boolean,
+)
+
+fun Routing.apiRoutes() {
+    route("/") {
+        get {
+            call.respondText("Hello World!", status =
+            HttpStatusCode.OK)
+        }
+    }
+    route("/health") {
+        get {
+            call.respondText("OK", status= HttpStatusCode.OK)
+        }
+    }
+
+    route("/user/{uid}") {
+        get {
+            val uid = call.parameters["uid"]
+            if(uid == null) {
+                call.respondText("Require UID", status = HttpStatusCode.NotFound)
+                return@get
+            }
+            val user = getStreamInfo(uid)
+            if(user.content == null) {
+                call.respondText("User not found", status = HttpStatusCode.NotFound)
+                return@get
+            } else {
+                call.respond(HttpStatusCode.OK, GetUserDTO(
+                    user.content!!.channel.channelId,
+                    user.content!!.channel.channelName,
+                    user.content!!.status == "OPEN",
+                    user.content!!.channel.channelImageUrl
+                ))
+            }
+        }
+    }
+    route("/user") {
+        get {
+            call.respondText("Require UID", status = HttpStatusCode.NotFound)
+        }
+    }
+    route("/session/{sid}") {
+        get {
+            val sid = call.parameters["sid"]
+            if(sid == null) {
+                call.respondText("Require SID", status = HttpStatusCode.NotFound)
+                return@get
+            }
+            val user = SongConfigService.getUserByToken(sid)
+            val session = SongConfigService.getConfig(sid)
+            if(user == null) {
+                call.respondText("User not found", status = HttpStatusCode.NotFound)
+                return@get
+            } else {
+                val chzzkUser = getStreamInfo(user.token)
+                call.respond(HttpStatusCode.OK, GetSessionDTO(
+                    chzzkUser.content!!.channel.channelId,
+                    chzzkUser.content!!.channel.channelName,
+                    chzzkUser.content!!.status == "OPEN",
+                    chzzkUser.content!!.channel.channelImageUrl,
+                    session!!.queueLimit,
+                    session.personalLimit,
+                    session.streamerOnly
+                ))
+            }
+        }
+    }
+    route("/session") {
+        get {
+            call.respondText("Require SID", status = HttpStatusCode.NotFound)
+        }
+    }
+}
--- a/webserver/src/main/kotlin/space/mori/chzzk_bot/webserver/routes/ApiSongRoutes.kt
+++ b/webserver/src/main/kotlin/space/mori/chzzk_bot/webserver/routes/ApiSongRoutes.kt
@@ -0,0 +1,48 @@
+package space.mori.chzzk_bot.webserver.routes
+
+import io.ktor.http.*
+import io.ktor.server.application.*
+import io.ktor.server.response.*
+import io.ktor.server.routing.*
+import kotlinx.serialization.Serializable
+import space.mori.chzzk_bot.common.models.SongList
+import space.mori.chzzk_bot.common.services.SongListService
+import space.mori.chzzk_bot.common.services.UserService
+
+@Serializable
+data class SongsDTO(
+    val url: String,
+    val name: String,
+    val author: String,
+    val time: Int,
+    val reqName: String
+)
+
+fun SongList.toDTO(): SongsDTO = SongsDTO(
+    this.url,
+    this.name,
+    this.author,
+    this.time,
+    this.reqName
+)
+
+fun Routing.apiSongRoutes() {
+    route("/songs/{uid}") {
+        get {
+            val uid = call.parameters["uid"]
+            val user = uid?.let { it1 -> UserService.getUser(it1) }
+            if (user == null) {
+                call.respondText("No user found", status = HttpStatusCode.NotFound)
+                return@get
+            }
+
+            val songs = SongListService.getSong(user)
+            call.respond(HttpStatusCode.OK, songs.map { it.toDTO() })
+        }
+    }
+    route("/songs") {
+        get {
+            call.respondText("Require UID", status= HttpStatusCode.BadRequest)
+        }
+    }
+}
--- a/webserver/src/main/kotlin/space/mori/chzzk_bot/webserver/routes/WSSongListRoutes.kt
+++ b/webserver/src/main/kotlin/space/mori/chzzk_bot/webserver/routes/WSSongListRoutes.kt
@@ -0,0 +1,210 @@
+package space.mori.chzzk_bot.webserver.routes
+
+import io.ktor.server.routing.*
+import io.ktor.server.websocket.*
+import io.ktor.websocket.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.channels.ClosedReceiveChannelException
+import kotlinx.coroutines.launch
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
+import org.koin.java.KoinJavaComponent.inject
+import org.slf4j.LoggerFactory
+import space.mori.chzzk_bot.common.events.*
+import space.mori.chzzk_bot.common.models.Counters.withDefinition
+import space.mori.chzzk_bot.common.services.SongConfigService
+import space.mori.chzzk_bot.common.services.SongListService
+import space.mori.chzzk_bot.common.services.UserService
+import space.mori.chzzk_bot.common.utils.getYoutubeVideo
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.ConcurrentLinkedQueue
+
+fun Routing.wsSongListRoutes() {
+    val sessions = ConcurrentHashMap<String, ConcurrentLinkedQueue<WebSocketServerSession>>()
+    val status = ConcurrentHashMap<String, SongType>()
+    val logger = LoggerFactory.getLogger("WSSongListRoutes")
+
+    val dispatcher: CoroutinesEventBus by inject(CoroutinesEventBus::class.java)
+
+    fun addSession(sid: String, session: WebSocketServerSession) {
+        sessions.computeIfAbsent(sid) { ConcurrentLinkedQueue() }.add(session)
+    }
+
+    fun removeSession(sid: String, session: WebSocketServerSession) {
+        sessions[sid]?.remove(session)
+        if(sessions[sid]?.isEmpty() == true) {
+            sessions.remove(sid)
+        }
+    }
+
+    webSocket("/songlist/{sid}") {
+        val sid = call.parameters["sid"]
+        val session = sid?.let { SongConfigService.getConfig(it) }
+        val user = sid?.let {SongConfigService.getUserByToken(sid) }
+        if (sid == null) {
+            close(CloseReason(CloseReason.Codes.CANNOT_ACCEPT, "Invalid SID"))
+            return@webSocket
+        }
+        if (user == null || session == null) {
+            close(CloseReason(CloseReason.Codes.CANNOT_ACCEPT, "Invalid SID"))
+            return@webSocket
+        }
+
+        addSession(sid, this)
+
+        if(status[sid] == SongType.STREAM_OFF) {
+            CoroutineScope(Dispatchers.Default).launch {
+                sendSerialized(SongResponse(
+                    SongType.STREAM_OFF.value,
+                    user.token,
+                    null,
+                    null,
+                    null,
+                    null,
+                    null
+                ))
+            }
+            removeSession(sid, this)
+        }
+
+        try {
+            for (frame in incoming) {
+                when(frame) {
+                    is Frame.Text -> {
+                        val data = frame.readText().let { Json.decodeFromString<SongRequest>(it) }
+
+                        if(data.maxQueue != null && data.maxQueue > 0) SongConfigService.updateQueueLimit(user, data.maxQueue)
+                        if(data.maxUserLimit != null && data.maxUserLimit > 0) SongConfigService.updatePersonalLimit(user, data.maxUserLimit)
+                        if(data.isStreamerOnly != null) SongConfigService.updateStreamerOnly(user, data.isStreamerOnly)
+
+                        if(data.type == SongType.ADD.value && data.url != null) {
+                            try {
+                                val youtubeVideo = getYoutubeVideo(data.url)
+                                if (youtubeVideo != null) {
+                                    CoroutineScope(Dispatchers.Default).launch {
+                                        SongListService.saveSong(
+                                            user,
+                                            user.token,
+                                            data.url,
+                                            youtubeVideo.name,
+                                            youtubeVideo.author,
+                                            youtubeVideo.length,
+                                            user.username
+                                        )
+                                        dispatcher.post(
+                                            SongEvent(
+                                                user.token,
+                                                SongType.ADD,
+                                                user.token,
+                                                user.username,
+                                                youtubeVideo.name,
+                                                youtubeVideo.author,
+                                                youtubeVideo.length,
+                                                youtubeVideo.url
+                                            )
+                                        )
+                                    }
+                                }
+                            } catch(e: Exception) {
+                                logger.debug("SongType.ADD Error: {} / {}", session.token, e)
+                            }
+                        }
+                        else if(data.type == SongType.REMOVE.value && data.url != null) {
+                            dispatcher.post(SongEvent(
+                                user.token,
+                                SongType.REMOVE,
+                                null,
+                                null,
+                                null,
+                                null,
+                                0,
+                                data.url
+                            ))
+                        } else if(data.type == SongType.NEXT.value) {
+                            val song = SongListService.getSong(user)[0]
+                            SongListService.deleteSong(user, song.uid, song.name)
+                            dispatcher.post(SongEvent(
+                                user.token,
+                                SongType.NEXT,
+                                null,
+                                null,
+                                null,
+                                null,
+                                null,
+                                null
+                            ))
+                        }
+                    }
+                    is Frame.Ping -> send(Frame.Pong(frame.data))
+                    else -> {
+
+                    }
+                }
+            }
+        } catch(e: ClosedReceiveChannelException) {
+            logger.error("Error in WebSocket: ${e.message}")
+        } finally {
+            removeSession(sid, this)
+        }
+    }
+
+    dispatcher.subscribe(SongEvent::class) {
+        logger.debug("SongEvent: {} / {} {}", it.uid, it.type, it.name)
+        CoroutineScope(Dispatchers.Default).launch {
+            val user = UserService.getUser(it.uid)
+            if(user != null) {
+                val session = SongConfigService.getConfig(user)
+                sessions[session.token ?: ""]?.forEach { ws ->
+                    ws.sendSerialized(
+                        SongResponse(
+                            it.type.value,
+                            it.uid,
+                            it.reqUid,
+                            it.name,
+                            it.author,
+                            it.time,
+                            it.url
+                        )
+                    )
+                }
+            }
+        }
+    }
+    dispatcher.subscribe(TimerEvent::class) {
+        if(it.type == TimerType.STREAM_OFF) {
+            CoroutineScope(Dispatchers.Default).launch {
+                val user = UserService.getUser(it.uid)
+                if(user != null) {
+                    val session = SongConfigService.getConfig(user)
+
+                    sessions[session.token ?: ""]?.forEach { ws ->
+                        ws.sendSerialized(
+                            SongResponse(
+                                it.type.value,
+                                it.uid,
+                                null,
+                                null,
+                                null,
+                                null,
+                                null
+                            )
+                        )
+                        removeSession(session.token ?: "", ws)
+                    }
+                }
+            }
+        }
+    }
+}
+
+@Serializable
+data class SongRequest(
+    val type: Int,
+    val uid: String,
+    val url: String?,
+    val maxQueue: Int?,
+    val maxUserLimit: Int?,
+    val isStreamerOnly: Boolean?,
+    val remove: Int?
+)
--- a/webserver/src/main/kotlin/space/mori/chzzk_bot/webserver/routes/WSSongRoutes.kt
+++ b/webserver/src/main/kotlin/space/mori/chzzk_bot/webserver/routes/WSSongRoutes.kt
@@ -0,0 +1,127 @@
+package space.mori.chzzk_bot.webserver.routes
+
+import io.ktor.server.routing.*
+import io.ktor.server.websocket.*
+import io.ktor.websocket.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.channels.ClosedReceiveChannelException
+import kotlinx.coroutines.launch
+import kotlinx.serialization.Serializable
+import org.koin.java.KoinJavaComponent.inject
+import org.slf4j.LoggerFactory
+import space.mori.chzzk_bot.common.events.*
+import space.mori.chzzk_bot.common.services.UserService
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.ConcurrentLinkedQueue
+
+fun Routing.wsSongRoutes() {
+    val sessions = ConcurrentHashMap<String, ConcurrentLinkedQueue<WebSocketServerSession>>()
+    val status = ConcurrentHashMap<String, SongType>()
+    val logger = LoggerFactory.getLogger("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) {
+            sessions.remove(uid)
+        }
+    }
+
+    webSocket("/song/{uid}") {
+        val uid = call.parameters["uid"]
+        val user = uid?.let { UserService.getUser(it) }
+        if (uid == null) {
+            close(CloseReason(CloseReason.Codes.CANNOT_ACCEPT, "Invalid UID"))
+            return@webSocket
+        }
+        if (user == null) {
+            close(CloseReason(CloseReason.Codes.CANNOT_ACCEPT, "Invalid UID"))
+            return@webSocket
+        }
+
+        addSession(uid, this)
+
+        if(status[uid] == SongType.STREAM_OFF) {
+            CoroutineScope(Dispatchers.Default).launch {
+                sendSerialized(SongResponse(
+                    SongType.STREAM_OFF.value,
+                    uid,
+                    null,
+                    null,
+                    null,
+                    null,
+                    null
+                ))
+            }
+        }
+
+        try {
+            for (frame in incoming) {
+                when(frame) {
+                    is Frame.Text -> {
+
+                    }
+                    is Frame.Ping -> send(Frame.Pong(frame.data))
+                    else -> {
+
+                    }
+                }
+            }
+        } catch(e: ClosedReceiveChannelException) {
+            logger.error("Error in WebSocket: ${e.message}")
+        } finally {
+            removeSession(uid, this)
+        }
+    }
+
+    val dispatcher: CoroutinesEventBus by inject(CoroutinesEventBus::class.java)
+
+    dispatcher.subscribe(SongEvent::class) {
+        logger.debug("SongEvent: {} / {} {}", it.uid, it.type, it.name)
+        CoroutineScope(Dispatchers.Default).launch {
+            sessions[it.uid]?.forEach { ws ->
+                ws.sendSerialized(SongResponse(
+                    it.type.value,
+                    it.uid,
+                    it.reqUid,
+                    it.name,
+                    it.author,
+                    it.time,
+                    it.url
+                ))
+            }
+        }
+    }
+    dispatcher.subscribe(TimerEvent::class) {
+        if(it.type == TimerType.STREAM_OFF) {
+            CoroutineScope(Dispatchers.Default).launch {
+                sessions[it.uid]?.forEach { ws ->
+                    ws.sendSerialized(SongResponse(
+                        it.type.value,
+                        it.uid,
+                        null,
+                        null,
+                        null,
+                        null,
+                        null
+                    ))
+                }
+            }
+        }
+    }
+}
+
+@Serializable
+data class SongResponse(
+    val type: Int,
+    val uid: String,
+    val reqUid: String?,
+    val name: String?,
+    val author: String?,
+    val time: Int?,
+    val url: String?
+)
--- a/webserver/src/main/kotlin/space/mori/chzzk_bot/webserver/routes/WSTimerRoutes.kt
+++ b/webserver/src/main/kotlin/space/mori/chzzk_bot/webserver/routes/WSTimerRoutes.kt
@@ -0,0 +1,98 @@
+package space.mori.chzzk_bot.webserver.routes
+
+import io.ktor.server.routing.*
+import io.ktor.server.websocket.*
+import io.ktor.websocket.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.channels.ClosedReceiveChannelException
+import kotlinx.coroutines.launch
+import kotlinx.serialization.Serializable
+import org.koin.java.KoinJavaComponent.inject
+import org.slf4j.LoggerFactory
+import space.mori.chzzk_bot.common.events.*
+import space.mori.chzzk_bot.common.services.TimerConfigService
+import space.mori.chzzk_bot.common.services.UserService
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.ConcurrentLinkedQueue
+
+fun Routing.wsTimerRoutes() {
+    val sessions = ConcurrentHashMap<String, ConcurrentLinkedQueue<WebSocketServerSession>>()
+    val status = ConcurrentHashMap<String, TimerType>()
+    val logger = LoggerFactory.getLogger("WSTimerRoutes")
+
+    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) {
+            sessions.remove(uid)
+        }
+    }
+
+    webSocket("/timer/{uid}") {
+        val uid = call.parameters["uid"]
+        val user = uid?.let { UserService.getUser(it) }
+        if (uid == null) {
+            close(CloseReason(CloseReason.Codes.CANNOT_ACCEPT, "Invalid UID"))
+            return@webSocket
+        }
+        if (user == null) {
+            close(CloseReason(CloseReason.Codes.CANNOT_ACCEPT, "Invalid UID"))
+            return@webSocket
+        }
+
+        addSession(uid, this)
+
+        if(status[uid] == TimerType.STREAM_OFF) {
+            CoroutineScope(Dispatchers.Default).launch {
+                sendSerialized(TimerResponse(TimerType.STREAM_OFF.value, null))
+            }
+        } else {
+            CoroutineScope(Dispatchers.Default).launch {
+                sendSerialized(TimerResponse(
+                    TimerConfigService.getConfig(user)?.option ?: TimerType.REMOVE.value,
+                    null
+                ))
+            }
+        }
+
+        try {
+            for (frame in incoming) {
+                when(frame) {
+                    is Frame.Text -> {
+
+                    }
+                    is Frame.Ping -> send(Frame.Pong(frame.data))
+                    else -> {
+
+                    }
+                }
+            }
+        } catch(e: ClosedReceiveChannelException) {
+            logger.error("Error in WebSocket: ${e.message}")
+        } finally {
+            removeSession(uid, this)
+        }
+    }
+
+    val dispatcher: CoroutinesEventBus by inject(CoroutinesEventBus::class.java)
+
+    dispatcher.subscribe(TimerEvent::class) {
+        logger.debug("TimerEvent: {} / {}", it.uid, it.type)
+        status[it.uid] = it.type
+        CoroutineScope(Dispatchers.Default).launch {
+            sessions[it.uid]?.forEach { ws ->
+                ws.sendSerialized(TimerResponse(it.type.value, it.time ?: ""))
+            }
+        }
+    }
+}
+
+@Serializable
+data class TimerResponse(
+    val type: Int,
+    val time: String?
+)
--- a/webserver/src/main/resources/openapi/documentation.yaml
+++ b/webserver/src/main/resources/openapi/documentation.yaml
@@ -0,0 +1,182 @@
+openapi: "3.1.0"
+info:
+  title: "chzzk_bot API"
+  description: "chzzk_bot API"
+  version: "1.0.0"
+servers:
+- url: "http://localhost:8080"
+paths:
+  /:
+    get:
+      description: ""
+      responses:
+        "200":
+          description: "OK"
+          content:
+            text/plain:
+              schema:
+                type: "string"
+              examples:
+                Example#1:
+                  value: "Hello World!"
+  /health:
+    get:
+      description: ""
+      responses:
+        "200":
+          description: "OK"
+          content:
+            text/plain:
+              schema:
+                type: "string"
+              examples:
+                Example#1:
+                  value: "OK"
+  /song/{uid}:
+    get:
+      description: ""
+      parameters:
+      - name: "uid"
+        in: "path"
+        required: true
+        schema:
+          type: "string"
+      - name: "Connection"
+        in: "header"
+        required: true
+        description: "Websocket Connection parameter"
+        schema:
+          type: "string"
+      - name: "Upgrade"
+        in: "header"
+        required: true
+        description: "Websocket Upgrade parameter"
+        schema:
+          type: "string"
+      - name: "Sec-WebSocket-Key"
+        in: "header"
+        required: true
+        description: "Websocket Sec-WebSocket-Key parameter"
+        schema:
+          type: "string"
+      responses:
+        "101":
+          description: "Switching Protocols"
+          headers:
+            Connection:
+              required: true
+              schema:
+                type: "string"
+            Upgrade:
+              required: true
+              schema:
+                type: "string"
+            Sec-WebSocket-Accept:
+              required: true
+              schema:
+                type: "string"
+  /songs:
+    get:
+      description: ""
+      responses:
+        "400":
+          description: "Bad Request"
+          content:
+            text/plain:
+              schema:
+                type: "string"
+              examples:
+                Example#1:
+                  value: "Require UID"
+  /songs/{uid}:
+    get:
+      description: ""
+      parameters:
+      - name: "uid"
+        in: "path"
+        required: true
+        schema:
+          type: "string"
+      responses:
+        "404":
+          description: "Not Found"
+          content:
+            text/plain:
+              schema:
+                type: "string"
+              examples:
+                Example#1:
+                  value: "No user found"
+        "200":
+          description: "OK"
+          content:
+            '*/*':
+              schema:
+                type: "array"
+                items:
+                  $ref: "#/components/schemas/SongList"
+  /timer/{uid}:
+    get:
+      description: ""
+      parameters:
+      - name: "uid"
+        in: "path"
+        required: true
+        schema:
+          type: "string"
+      - name: "Connection"
+        in: "header"
+        required: true
+        description: "Websocket Connection parameter"
+        schema:
+          type: "string"
+      - name: "Upgrade"
+        in: "header"
+        required: true
+        description: "Websocket Upgrade parameter"
+        schema:
+          type: "string"
+      - name: "Sec-WebSocket-Key"
+        in: "header"
+        required: true
+        description: "Websocket Sec-WebSocket-Key parameter"
+        schema:
+          type: "string"
+      responses:
+        "101":
+          description: "Switching Protocols"
+          headers:
+            Connection:
+              required: true
+              schema:
+                type: "string"
+            Upgrade:
+              required: true
+              schema:
+                type: "string"
+            Sec-WebSocket-Accept:
+              required: true
+              schema:
+                type: "string"
+components:
+  schemas:
+    Object:
+      type: "object"
+      properties: {}
+    ResultRow:
+      type: "object"
+      properties:
+        fieldIndex:
+          type: "object"
+      required:
+      - "fieldIndex"
+    SongList:
+      type: "object"
+      properties:
+        writeValues:
+          $ref: "#/components/schemas/Object"
+        _readValues:
+          $ref: "#/components/schemas/ResultRow"
+      required:
+      - "id"
+      - "writeValues"
Author	SHA1	Message	Date
JinU Choi	2f5c4293c0	Merge pull request #45 from dalbodeule/develop RegisterCommand some fix	2024-08-08 10:12:49 +09:00
dalbodeule	0317c80ccf	RegisterCommand some fix - add regex match logics. it can to register with chzzk channel/studio URL	2024-08-08 09:42:37 +09:00
JinU Choi	8d50d1c3aa	Merge pull request #44 from dalbodeule/develop some logic changed.	2024-08-07 13:18:05 +09:00
dalbodeule	de30e632e5	some logic changed.	2024-08-07 13:12:38 +09:00
JinU Choi	5d0fe98c66	Merge pull request #43 from dalbodeule/develop add try-catch in stream on discords.	2024-08-07 08:59:19 +09:00
dalbodeule	608ba49a71	add try-catch in stream on discords.	2024-08-07 08:55:50 +09:00
dalbodeule	5a46e62a61	some fix - final - debug searchYoutube fun (8x)	2024-08-06 21:12:44 +09:00
dalbodeule	833bfbd46d	some fix - debug searchYoutube fun (7x)	2024-08-06 21:09:30 +09:00
dalbodeule	76ffebc157	some fix - debug searchYoutube fun (6x)	2024-08-06 21:05:39 +09:00
dalbodeule	e8bee6ff23	some fix - debug searchYoutube fun (5x)	2024-08-06 20:57:21 +09:00
dalbodeule	60523f992b	some fix - debug searchYoutube fun (4x)	2024-08-06 20:52:42 +09:00
dalbodeule	a10579ea6b	some fix - debug searchYoutube fun (3x)	2024-08-06 20:49:47 +09:00
dalbodeule	5dcbbdeb80	some fix - debug searchYoutube fun (2x)	2024-08-06 20:44:46 +09:00
dalbodeule	bedd5406a0	some fix - debug searchYoutube fun	2024-08-06 20:37:34 +09:00
dalbodeule	a50a3f21a3	some fix - (tmp add) logger.info	2024-08-06 20:29:41 +09:00
JinU Choi	c9ad739d05	Merge pull request #42 from dalbodeule/develop some fix	2024-08-06 20:17:33 +09:00
dalbodeule	d329b8bdb3	some fix - add searchYoutube function. - add try-catch blocks.	2024-08-06 20:14:34 +09:00
JinU Choi	816c82e57b	Merge pull request #41 from dalbodeule/develop some fix	2024-08-05 21:19:59 +09:00
dalbodeule	debbd61aa7	some fix - "!노래추가" command append limits.	2024-08-05 21:16:41 +09:00
JinU Choi	3e3a283a16	Merge pull request #40 from dalbodeule/develop some fix	2024-08-05 20:59:30 +09:00
dalbodeule	c5f8ce7528	some fix - "!명령어추가", "!명령어수정", "!명령어삭제" command fix. (is able reload) - on /session/{sid} endpoint, add streamer configs	2024-08-05 20:55:18 +09:00
JinU Choi	7df2b68a5f	Merge pull request #39 from dalbodeule/develop some fix	2024-08-05 20:46:52 +09:00
dalbodeule	778fe8df34	some fix - !노래시작 command URL typo. - SongEvent(SongType.REMOVE) debug in WSSongListRoutes	2024-08-05 20:45:34 +09:00
JinU Choi	4c5fa5742f	Merge pull request #38 from dalbodeule/develop some fix WSSongListRoutes.kt	2024-08-05 18:33:48 +09:00
dalbodeule	4f589780b8	some fix WSSongListRoutes.kt - add url parameters	2024-08-05 18:06:46 +09:00
JinU Choi	d5dc7a61c9	Merge pull request #37 from dalbodeule/develop some fix WSSongListRoutes.kt	2024-08-05 16:25:46 +09:00
dalbodeule	9b046d38b9	some fix WSSongListRoutes.kt - add PacketType Handler. - add SongType.NEXT handler.	2024-08-05 16:23:46 +09:00
JinU Choi	8e2c0243bb	Merge pull request #36 from dalbodeule/develop some fix WSSongListRoutes.kt	2024-08-05 15:02:11 +09:00
dalbodeule	75da1c1576	some fix WSSongListRoutes.kt - delete websocket key - else updated.	2024-08-05 14:38:16 +09:00
JinU Choi	fdd8eeda23	Merge pull request #35 from dalbodeule/develop some improve WSApis	2024-08-05 13:30:07 +09:00
dalbodeule	cc23ac03e7	some improve WSApis - with WSSongListRoutes.kt, data receive logics. - else WSAPI's logger name changed. - MessageHandler.kt "!노래시작" command improved.	2024-08-05 13:25:28 +09:00
JinU Choi	240503a4d5	Merge pull request #34 from dalbodeule/develop add WSSongListRoutes.kt	2024-08-05 12:43:58 +09:00
dalbodeule	0a4e8193bb	add WSSongListRoutes.kt - add Websocket backend. - add session start command. - some improve logics.	2024-08-05 12:35:11 +09:00
JinU Choi	59b90f2bcf	Merge pull request #33 from dalbodeule/develop Add command, update document.	2024-08-04 21:57:28 +09:00
dalbodeule	47228394d5	Add command, update document. - add !노래목록 command - Document add (timer, playlist commands)	2024-08-04 21:54:55 +09:00
JinU Choi	04f6b14daa	Merge pull request #32 from dalbodeule/develop Fix /user/{uid} endoints.	2024-08-04 20:32:40 +09:00
dalbodeule	6da0662e2a	Fix /user/{uid} endoints. - ChzzkApis.kt moved to common - ChzzkApis.kt response data is nullable data. - if require {uid}'s data, getStreamInfo function called.	2024-08-04 20:27:54 +09:00
JinU Choi	5c93476c34	Merge pull request #31 from dalbodeule/develop koin not started bug fix	2024-08-04 19:02:12 +09:00
dalbodeule	514ab14c3c	koin not started bug fix	2024-08-04 18:59:40 +09:00
JinU Choi	13ce148fc5	Merge pull request #30 from dalbodeule/develop add /user/{uid} endoints.	2024-08-04 18:55:25 +09:00
dalbodeule	4025cbceec	add /user/{uid} call on web module. - fix some bug with use Pair	2024-08-04 18:51:41 +09:00
dalbodeule	b77a3d02c5	add /user/{uid} call on web module. - add GetUserEvents. - add /user/{uid} backends.	2024-08-04 18:47:13 +09:00
dalbodeule	4d63022130	some debugs on ChzzkHandler	2024-08-04 17:25:47 +09:00
JinU Choi	aad10a0f44	Merge pull request #29 from dalbodeule/develop some debugs on WSTimerRoutes.kt again	2024-08-04 16:11:06 +09:00
dalbodeule	5a050f9d5c	some debugs on WSTimerRoutes.kt again	2024-08-04 16:07:51 +09:00
JinU Choi	2f73204c6a	Merge pull request #28 from dalbodeule/develop some debugs on WSTimerRoutes.kt	2024-08-04 15:50:30 +09:00
dalbodeule	37b5fda691	some debugs on WSTimerRoutes.kt	2024-08-04 15:47:10 +09:00
JinU Choi	4f31d87b3b	Merge pull request #27 from dalbodeule/develop some debugs on Chisu playlist	2024-08-04 15:32:54 +09:00
dalbodeule	590c1203bd	some debugs on Chisu playlist	2024-08-04 15:30:00 +09:00
JinU Choi	cc81e6d722	Merge pull request #26 from dalbodeule/develop add Chisu playlist, etc...	2024-08-04 14:25:51 +09:00
dalbodeule	f7953778e1	some debugs on AddCommand - add spaces.	2024-08-04 14:10:37 +09:00
dalbodeule	b803aeca1d	add Chisu playlist functions - add SongLists, SongConfigs to creation table lists.	2024-08-04 14:09:48 +09:00
dalbodeule	91573a4048	add Chisu playlist functions - add Websocket - add API - version up to 1.2.0	2024-08-04 14:09:11 +09:00
dalbodeule	dc81bb09f2	add Chisu playlist functions - add Playlist, Playlist settings configs. - add "!노래추가" command	2024-08-04 13:50:05 +09:00
JinU Choi	60319bc6fa	Merge pull request #25 from dalbodeule/develop some change on LiveStatus logics	2024-08-03 23:47:23 +09:00
dalbodeule	1be1b69425	some change on LiveStatus logics - add LiveStatus table - in ChzzkHandler.kt (UserHandler), _isActive variable to bind LiveStatusService	2024-08-03 23:44:10 +09:00
JinU Choi	5b19331890	Merge pull request #24 from dalbodeule/develop some changes on Connector, RegisterCommand	2024-08-03 21:46:24 +09:00
dalbodeule	d323bf28db	some changes on Connector, RegisterCommand	2024-08-03 21:43:02 +09:00
JinU Choi	b3da9db627	Merge pull request #23 from dalbodeule/develop add TimerConfig.kt, TimerConfigService	2024-08-03 13:59:55 +09:00
dalbodeule	f7c68a56bc	add TimerConfig.kt, TimerConfigService	2024-08-03 13:57:03 +09:00
JinU Choi	39237a35c9	Merge pull request #22 from dalbodeule/develop Chzzk uptime is in status.	2024-08-03 09:30:01 +09:00
dalbodeule	55f6f5f94d	Chzzk uptime is in status. - status:IData<StreamInfo> 's openDate is real uptime.	2024-08-03 09:25:28 +09:00
JinU Choi	65fb2ac3e3	Merge pull request #21 from dalbodeule/develop in WSTimerRoutes.kt, send data two or many session on one uid.	2024-08-02 15:44:35 +09:00
dalbodeule	e4a2d28b3c	in WSTimerRoutes.kt, send data two or many session on one uid.	2024-08-02 15:42:07 +09:00
JinU Choi	01778b801a	Merge pull request #20 from dalbodeule/develop add TimerType.STREAM_OFF status.	2024-08-02 15:08:37 +09:00
dalbodeule	8e9382cb3a	add TimerType.STREAM_OFF status. - if connected on stream off status, TimerType.STREAM_OFF message sent. - if stream on, default type is TimerType.UPTIME	2024-08-02 14:52:28 +09:00
JinU Choi	070df6b68b	Merge pull request #19 from dalbodeule/develop some debug on WSTimerRoutes.kt	2024-08-01 21:26:35 +09:00
dalbodeule	65d491cc8e	some debug on WSTimerRoutes.kt	2024-08-01 21:24:20 +09:00
JinU Choi	df0c301079	Merge pull request #18 from dalbodeule/develop some debug on TimerEvents	2024-08-01 20:37:11 +09:00
dalbodeule	6b533bcee9	some debug on TimerEvents	2024-08-01 20:29:01 +09:00
JinU Choi	2989816a1a	Merge pull request #17 from dalbodeule/develop debug MessageHandler.kt	2024-07-31 23:45:27 +09:00
dalbodeule	75b983a02b	debug MessageHandler.kt	2024-07-31 23:43:55 +09:00
JinU Choi	b92b11bf06	Merge pull request #16 from dalbodeule/develop CoroutinesEventBus add.	2024-07-31 16:21:14 +09:00
dalbodeule	180dbc85bf	CoroutinesEventBus add. - koin dependency injection add - EventDispatcher fix	2024-07-31 16:14:58 +09:00
JinU Choi	53cefe5813	Merge pull request #15 from dalbodeule/develop some change on TimerEvents.	2024-07-30 23:01:57 +09:00
dalbodeule	99ec9ba7a0	some change on TimerEvents.	2024-07-30 23:00:29 +09:00
JinU Choi	85ad7fe5ad	Merge pull request #14 from dalbodeule/develop add WebSocket timers	2024-07-30 22:42:22 +09:00
dalbodeule	a9ee40e936	add WebSocket timers - EventDispatcher, TimerEvent add.	2024-07-30 22:40:07 +09:00
JinU Choi	da13e8b834	Merge pull request #13 from dalbodeule/develop debugs some codes.	2024-07-30 16:25:49 +09:00
dalbodeule	65ff475d0a	debugs some codes.	2024-07-30 16:24:18 +09:00
JinU Choi	e8baa393cf	Merge pull request #12 from dalbodeule/develop debug with eagerLoading	2024-07-30 15:50:11 +09:00
dalbodeule	8365fa1767	debug with eagerLoading - debug with eagerLoading. Exposed is lazyLoading. But, This program requires eagerLoading. So, I make eagerLoading methods.	2024-07-30 15:48:39 +09:00
JinU Choi	e16a8b6fc0	Merge pull request #11 from dalbodeule/develop add webserver, etc...	2024-07-30 14:32:09 +09:00
dalbodeule	72f98b024b	add webserver, etc... - add ktor webserver - package is subpackaged.	2024-07-30 14:28:43 +09:00
JinU Choi	1d23ac5121	Merge pull request #10 from dalbodeule/develop BUG FIX: fix #9	2024-07-29 16:01:30 +09:00
dalbodeule	8f8d2f895a	BUG FIX: fix #9	2024-07-29 15:58:50 +09:00
JinU Choi	47b4b8252f	Merge pull request #8 from dalbodeule/develop BUG FIX: daily counter with update updated_at column	2024-07-27 21:09:48 +09:00
dalbodeule	64880318e8	BUG FIX: daily counter with update updated_at column	2024-07-27 21:06:56 +09:00
JinU Choi	cec07f9859	Merge pull request #7 from dalbodeule/develop add guild update, update document, update version to 1.0.1	2024-07-27 11:38:26 +09:00
dalbodeule	18ee27e567	add guild update, update document, update version to 1.0.1	2024-07-27 11:36:17 +09:00
JinU Choi	34ec0f29ff	Merge pull request #6 from dalbodeule/develop v1.0.0 - add managers (in discord) - manager can add/remove/modify commands - update some packages.	2024-07-27 10:23:50 +09:00
dalbodeule	2b999c5acb	dockerfile update	2024-07-27 10:20:32 +09:00
dalbodeule	c669943f87	manager can add/update/delete commands	2024-07-27 10:13:33 +09:00
dalbodeule	efaaf5ae9f	update library versions	2024-07-27 09:54:22 +09:00
JinU Choi	c8fca6995c	Merge pull request #5 from dalbodeule/develop Add discord managers.	2024-07-26 20:28:46 +09:00
dalbodeule	903f1f7f38	add Manager add/remove/list command, database tables.	2024-07-26 20:24:37 +09:00
dalbodeule	e4b6f819ca	some improve MessageHandler.kt	2024-07-26 19:20:10 +09:00
JinU Choi	2c1f42e4af	Merge pull request #4 from dalbodeule/develop add days placeholder	2024-07-23 17:47:44 +09:00
dalbodeule	ff90e5fe7f	add days placeholder - days placeholder <days:yyyy-mm-dd> pattern added.	2024-07-23 17:44:28 +09:00
JinU Choi	a227dda930	Merge pull request #3 from dalbodeule/develop fix README.md (with commands, placeholders, stacks)	2024-07-22 10:53:24 +09:00
dalbodeule	3e09989202	fix README.md (with commands, placeholders, stacks)	2024-07-22 10:45:52 +09:00
dalbodeule	eddca6dbab	fix README.md	2024-07-19 13:30:45 +09:00
dalbodeule	9c48dd676e	remove github ci/cd	2024-07-18 23:17:32 +09:00
dalbodeule	779604d21e	update README.md	2024-07-18 23:00:36 +09:00
dalbodeule	83791fe59b	remove useless prints.	2024-07-15 10:16:12 +09:00
dalbodeule	fe63a4af15	chzzk followdate fix	2024-07-14 19:47:12 +09:00
dalbodeule	7522ec6f9e	chzzk followdate error handler add	2024-07-14 18:37:52 +09:00
dalbodeule	c35b3082cc	log debug to info. level changed	2024-07-05 14:06:31 +09:00