Change CLI to use kordx.commands

Use kts build script
Update dependencies

.gitignore

@@ -1,6 +1,7 @@
 servers.json
-admin.json
+config.json
 service_channels.json
 *.hprof
-/build
+/build/
-/.gradle
+/.gradle/
+/.idea/

README.md

@@ -31,9 +31,9 @@ the bot should message you on Discord.
 
 *Note:* You need to invite the bot into a server before it can message you.
 
-Run it once (it should crash or print an error), so `admin.json`, `servers.json` and `service_channels.json`
+Run it once (it should crash or print an error), so `config.json`, `servers.json` and `service_channels.json`
 are being created.
-Add your Discord ID `adminId` (not name), Bot token `token`, and update frequency `updateMs` to the `admin.json`,
+Add your Discord ID `adminId` (not name), Bot token `token`, and update frequency `updateMs` to the `config.json`,
 optionally you can add your own messages for when the bot is looking and when it can't reach Hytale Servers.
 
 If you verified that everything works correctly, you can start the server in the background, on Linux that is
@@ -59,7 +59,7 @@ I developed it under Windows, and had some trouble compiling it on Linux. You mi
 | !help | | Show a help dialog with all these commands |
 
 These commands will only work by private messaging the bot (and will be ignored if they don't
-come from the admin registered in the `admin.json`.
+come from the admin registered in the `config.json`.
 
 ## TODO
 

build.gradle

@@ -1,47 +0,0 @@
-plugins {
-    id 'org.jetbrains.kotlin.jvm' version '1.3.61'
-    id 'org.jetbrains.kotlin.plugin.serialization' version '1.3.61'
-}
-
-group 'de.wulkanat'
-version '1.4.3'
-
-repositories {
-    mavenCentral()
-    jcenter()
-}
-
-dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
-
-    compile 'net.dv8tion:JDA:4.2.0_189'
-    compile 'org.jsoup:jsoup:1.13.1'
-    compile "org.jetbrains.kotlinx:kotlinx-serialization-runtime:0.14.0"
-}
-
-compileKotlin {
-    kotlinOptions.jvmTarget = "1.8"
-}
-compileTestKotlin {
-    kotlinOptions.jvmTarget = "1.8"
-}
-
-jar {
-    manifest {
-        attributes('Main-Class': 'de.wulkanat.MainKt')
-    }
-}
-
-task fatJar(type: Jar) {
-    baseName = project.name + '-all'
-    from((configurations.compile.findAll { !it.path.endsWith(".pom") }).collect {
-        it.isDirectory() ? it : zipTree(it)
-    })
-    with jar
-    manifest {
-        attributes 'Main-Class': 'de.wulkanat.MainKt',
-                'Implementation-Version': version
-    }
-}
-
-apply plugin: 'kotlinx-serialization'

build.gradle.kts

@@ -0,0 +1,61 @@
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+    val kotlinVersion = "1.4.10"
+
+    kotlin("jvm") version kotlinVersion
+    kotlin("plugin.serialization") version kotlinVersion
+
+    id("org.jetbrains.kotlin.kapt") version kotlinVersion
+}
+
+group = "de.wulkanat"
+version = "2.0.0"
+
+repositories {
+    mavenCentral()
+    jcenter()
+    maven("https://kotlin.bintray.com/koltinx")
+    maven("https://dl.bintray.com/kordlib/Kord")
+}
+
+dependencies {
+    testImplementation(kotlin("test-junit"))
+
+    implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
+
+    implementation("org.jsoup:jsoup:1.13.1")
+
+    implementation("dev.kord:kord-common:0.7.0-RC")
+    implementation("com.gitlab.kordlib.kordx:kordx-commands-runtime-kord:0.3.4")
+    implementation("com.gitlab.kordlib:kordx.emoji:0.4.0")
+
+    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.0.1")
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.4.2")
+
+    kapt("com.gitlab.kordlib.kordx:kordx-commands-processor:0.3.4")
+}
+
+tasks.test {
+    useJUnit()
+}
+
+tasks.withType<KotlinCompile> {
+    kotlinOptions.jvmTarget = "1.8"
+}
+
+tasks.withType<Jar> {
+    manifest {
+        attributes(mapOf(Pair("Main-Class", "de.wulkanat.MainKt")))
+    }
+}
+
+tasks.create<Jar>("fatJar") {
+    archiveBaseName.set("${project.name}-all")
+    manifest {
+        attributes["Implementation-Version"] = archiveVersion
+        attributes["Main-Class"] = "de.wulkanat.MainKt"
+    }
+    from(configurations.runtimeClasspath.get().map { if (it.isDirectory) it else zipTree(it) })
+    with(tasks.jar.get() as CopySpec)
+}

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,5 @@
-#Thu Aug 13 18:41:46 CEST 2020
-distributionUrl=https\://services.gradle.org/distributions/gradle-5.2.1-all.zip
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.7.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

settings.gradle

@@ -1,2 +0,0 @@
-rootProject.name = 'HytaleUpdateBot'
-

settings.gradle.kts

@@ -0,0 +1,2 @@
+rootProject.name = "HytaleUpdateBot"
+

src/main/kotlin/de/wulkanat/Admin.kt

@@ -1,141 +1,82 @@
 package de.wulkanat
 
-import kotlinx.serialization.json.Json
+import com.gitlab.kordlib.common.entity.Snowflake
-import kotlinx.serialization.json.JsonConfiguration
+import com.gitlab.kordlib.core.Kord
-import net.dv8tion.jda.api.EmbedBuilder
+import com.gitlab.kordlib.core.behavior.channel.createEmbed
-import net.dv8tion.jda.api.JDA
+import com.gitlab.kordlib.core.entity.User
-import net.dv8tion.jda.api.entities.Activity
+import com.gitlab.kordlib.rest.builder.message.EmbedBuilder
-import net.dv8tion.jda.api.entities.MessageEmbed
+import de.wulkanat.files.Config
-import net.dv8tion.jda.api.entities.User
+import de.wulkanat.files.ServiceChannels
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
 import java.awt.Color
 
 object Admin {
-    val userId: Long
+    var jda: Kord? = null
-    val token: String
-    val updateMs: Long
-    val message: String
-    val offlineMessage: String
-
-    init {
-        val admin = Json(JsonConfiguration.Stable).parse(AdminFile.serializer(), ADMIN_FILE.readText())
-        userId = admin.adminId
-        token = admin.token
-        updateMs = admin.updateMs
-        message = admin.watchingMessage
-        offlineMessage = admin.offlineMessage
-    }
-
-    var jda: JDA? = null
     set(value) {
         field = value
 
-        admin = value?.retrieveUserById(userId)?.complete()
+        GlobalScope.launch {
-        if (admin == null) {
+            admin = value?.getUser(Snowflake(Config.adminId))
-            kotlin.io.println("Connection to de.wulkanat.Admin failed!")
+            if (admin == null) {
-        } else {
+                kotlin.io.println("Connection to de.wulkanat.Admin failed!")
-            kotlin.io.println("Connected to ${admin!!.name}. No further errors will be printed here.")
+            } else {
+                kotlin.io.println("Connected to ${admin!!.username}. No further errors will be printed here.")
+            }
         }
     }
     var admin: User? = null
 
-    fun println(msg: String) {
+    suspend fun println(msg: String) {
-        sendDevMessage(
+        sendDevMessage(msg) {
-            EmbedBuilder()
+            title = msg
-                .setTitle(msg)
+            color = Color.WHITE
-                .setColor(Color.WHITE)
+        }
-                .build(),
-            msg
-        )
     }
 
-    fun printlnBlocking(msg: String) {
+    suspend fun error(msg: String, error: String, author: User? = null) {
-        senDevMessageBlocking(
+        sendDevMessage("$msg\n\n$error") {
-            EmbedBuilder()
+            title = msg
-                .setTitle(msg)
+            description = error
-                .setColor(Color.WHITE)
+            color = Color.RED
-                .build(),
+            author?.let { author {
-            msg
+                name = it.tag
-        )
+                icon = it.avatar.url
+                url = it.avatar.url
+            }}
+        }
     }
 
-    fun error(msg: String, error: String, author: User? = null) {
+    suspend fun warning(msg: String) {
-        sendDevMessage(
+        sendDevMessage(msg) {
-            EmbedBuilder()
+            title = msg
-                .setTitle(msg)
+            color = Color.YELLOW
-                .setDescription(error)
+        }
-                .setColor(Color.RED)
-                .run {
-                    if (author == null) {
-                        this
-                    } else {
-                        this.setAuthor(author.asTag, author.avatarUrl, author.avatarUrl)
-                    }
-                }
-                .build()
-            , "$msg\n\n${error}"
-        )
     }
 
-    fun errorBlocking(msg: String, error: Exception) {
+    suspend fun info() {
-        senDevMessageBlocking(
+        sendDevMessage("Now watching for new Hytale BlogPosts") {
-            EmbedBuilder()
+            title = "Now watching for new Hytale Blogposts every ${Config.updateMs / 1000}s"
-                .setTitle(msg)
+            description = """
-                .setDescription(error.message)
+                ${ServiceChannels.getServerNames().joinToString("\n")}
-                .setColor(Color.RED)
-                .build()
-            , "$msg\n\n${error.message}"
-        )
-    }
                 
-    fun warning(msg: String) {
+                **_Service Channels_**
-        sendDevMessage(
+                ${ServiceChannels.getServiceChannelServers().joinToString("\n")}
-            EmbedBuilder()
+            """.trimIndent()
-                .setTitle(msg)
+            color = Color.GREEN
-                .setColor(Color.YELLOW)
+        }
-                .build(),
-            msg
-        )
-    }
-
-    fun info() {
-        sendDevMessage(
-            EmbedBuilder()
-                .setTitle("Now watching for new Hytale Blogposts every ${updateMs / 1000}s")
-                .setDescription("""
-                    ${Channels.getServerNames().joinToString("\n")}
-                    
-                    **_Service Channels_**
-                    ${Channels.getServiceChannelServers().joinToString("\n")}
-                """.trimIndent())
-                .setColor(Color.GREEN)
-                .build(),
-            "Now watching for new Hytale BlogPosts"
-        )
     }
 
     fun silent(msg: String) {
         kotlin.io.println(msg)
     }
 
-    private fun senDevMessageBlocking(messageEmbed: MessageEmbed, fallback: String) {
+    private suspend inline fun sendDevMessage(fallback: String, crossinline embed: EmbedBuilder.() -> Unit) {
-        admin = jda!!.retrieveUserById(userId).complete()
+        val devChannel = admin?.getDmChannel() ?: kotlin.run {
-        val devChannel = admin?.openPrivateChannel() ?: kotlin.run {
             kotlin.io.println(fallback)
             return
         }
 
-        devChannel.complete()
+        devChannel.createEmbed(embed)
-            .sendMessage(messageEmbed).complete()
-    }
-
-    fun sendDevMessage(messageEmbed: MessageEmbed, fallback: String) {
-        val devChannel = admin?.openPrivateChannel() ?: kotlin.run {
-            kotlin.io.println(fallback)
-            return
-        }
-
-        devChannel.queue {
-            it.sendMessage(messageEmbed).queue()
-        }
     }
 }

src/main/kotlin/de/wulkanat/AdminCli.kt

@@ -1,91 +0,0 @@
-package de.wulkanat
-
-import de.wulkanat.model.BlogPostPreview
-import net.dv8tion.jda.api.hooks.ListenerAdapter
-import de.wulkanat.web.SiteWatcher
-import net.dv8tion.jda.api.EmbedBuilder
-import net.dv8tion.jda.api.events.message.priv.PrivateMessageReceivedEvent
-import java.awt.Color
-import kotlin.system.exitProcess
-
-class AdminCli : ListenerAdapter() {
-    val prefix = "!"
-
-    override fun onPrivateMessageReceived(event: PrivateMessageReceivedEvent) {
-        val msg = event.message.contentRaw
-        if (event.author.idLong != Admin.userId ||
-            !msg.startsWith(prefix)
-        ) {
-            return
-        }
-        val command = Regex("[^\\s`]+|`[^`]*`").findAll(msg.removePrefix("!")).toList()
-
-        when (command[0].value) {
-            "stop" -> exitProcess(1)
-            "fakeUpdate" -> {
-                SiteWatcher.newestBlog = BlogPostPreview(
-                    title = "FakePost",
-                    imgUrl = "",
-                    fullPostUrl = "",
-                    author = "wulkanat",
-                    date = "now",
-                    description = "Lorem Ipsum"
-                )
-
-                Admin.println("Posting on next update cycle.")
-            }
-            "info" -> {
-                Admin.info()
-            }
-            "serviceMessage" -> {
-                if (command.size != 3) {
-                    Admin.println("Enclose message and title in backticks (`)")
-                } else {
-                    Channels.sendServiceMessage(command[1].value.trim('`'), command[2].value.trim('`'))
-                }
-            }
-            "refreshList" -> {
-                Channels.channels = Channels.refreshChannelsFromDisk()
-                Channels.serviceChannels = Channels.refreshServiceChannelsFromDisk()
-                Admin.info()
-            }
-            "removeInactive" -> {
-                Channels.channels.removeAll { channel ->
-                    Channels.testServerId(channel.id) ?: run {
-                        Admin.println("Removed ${channel.id}")
-                        null
-                    } == null
-                }
-                Admin.info()
-                Channels.saveChannels()
-            }
-            "help" -> {
-                event.message.channel.sendMessage(
-                    EmbedBuilder()
-                        .setTitle("Help")
-                        .setColor(Color.YELLOW)
-                        .setAuthor(Admin.admin?.name, Admin.admin?.avatarUrl, Admin.admin?.avatarUrl)
-                        .setDescription(
-                            """
-                            **${prefix}stop**
-                            Stop the bot
-                            **${prefix}fakeUpdate**
-                            Post a fake update to every registered channel (can be used if bot missed the update)
-                            **${prefix}info**
-                            Show an overview over all registered channels
-                            **${prefix}serviceMessage [title] [message]**
-                            Show a service message (update info etc) to all registered service channels
-                            **${prefix}refreshList**
-                            Refresh server list from disk
-                            **${prefix}removeInactive**
-                            Remove inactive channels
-                            **${prefix}help**
-                            Show this message
-                        """.trimIndent()
-                        )
-                        .build()
-                ).queue()
-            }
-        }
-    }
-}

src/main/kotlin/de/wulkanat/DataIO.kt

@@ -10,7 +10,7 @@ import java.io.File
 @Serializable
 data class DiscordChannel(
     val id: Long,
-    var mentionedRole: String? = null,
+    var mentionedRole: Long? = null,
     var autoPublish: Boolean = false,
     var message: CustomMessage? = null
 )

src/main/kotlin/de/wulkanat/Main.kt

@@ -1,5 +1,6 @@
 package de.wulkanat
 
+import de.wulkanat.files.ServiceChannels
 import net.dv8tion.jda.api.JDABuilder
 import net.dv8tion.jda.api.entities.Activity
 import net.dv8tion.jda.api.requests.GatewayIntent
@@ -18,7 +19,7 @@ fun main() {
     builder.addEventListener(OwnerCli())
     builder.awaitReady()
 
-    Channels.jda = builder
+    ServiceChannels.client = builder
     Admin.jda = builder
     DiscordRpc.jda = builder
     Admin.info()
@@ -34,7 +35,7 @@ fun main() {
 
     timer("Updater", daemon = true, initialDelay = 0L, period = Admin.updateMs) {
         if (SiteWatcher.hasNewBlogPost()) {
-            Channels.sentToAll(SiteWatcher.newestBlog!!.toMessageEmbed())
+            ServiceChannels.sentToAll(SiteWatcher.newestBlog!!.toMessageEmbed())
         }
     }
 }

src/main/kotlin/de/wulkanat/OwnerCli.kt

@@ -1,215 +0,0 @@
-package de.wulkanat
-
-import net.dv8tion.jda.api.EmbedBuilder
-import net.dv8tion.jda.api.Permission
-import net.dv8tion.jda.api.events.message.MessageReceivedEvent
-import net.dv8tion.jda.api.hooks.ListenerAdapter
-import java.awt.Color
-
-class OwnerCli : ListenerAdapter() {
-    private val prefix = "%!"
-
-    override fun onMessageReceived(event: MessageReceivedEvent) {
-        val msg = event.message.contentRaw
-        // Only accept admin requests
-        if (event.message.member?.hasPermission(Permission.ADMINISTRATOR) != true || !msg.startsWith(prefix)) {
-            return
-        }
-
-        val command = msg.removePrefix(prefix).split(Regex("\\s+"))
-        val channelId = event.message.channel.idLong
-
-        when (command.first()) {
-            "add" -> {
-                val result = Channels.addChannel(channelId, null)
-                if (result == null) {
-                    event.message.channel.sendMessage("Already added.").queue()
-                } else {
-                    event.message.channel.sendMessage("Added.").queue()
-                    Admin.info()
-                }
-            }
-            "remove" -> {
-                val result = Channels.channels.removeAll { it.id == channelId }
-                Channels.saveChannels()
-                if (result) {
-                    event.message.channel.sendMessage("Removed.").queue()
-                } else {
-                    event.message.channel.sendMessage("This channel is not registered.").queue()
-                }
-            }
-            "publish" -> {
-                val result = Channels.channels.find { it.id == channelId }
-                if (result != null) {
-                    if (command.size > 1 && listOf("on", "off").contains(command[1])) {
-                        result.autoPublish = command[1] == "on"
-                        Channels.saveChannels()
-
-                        event.message.channel.sendMessage("Auto publish is now ${command[1]}").queue()
-                    } else {
-                        event.message.channel.sendMessage("Usage: `${prefix}publish [on|off]`")
-                    }
-                } else {
-                    event.message.channel.sendMessage("Channel not registered.").queue()
-                }
-            }
-            "ping" -> {
-                val result = Channels.channels.find { it.id == channelId }
-                if (result != null) {
-                    if (command.size > 1) {
-                        val roles = event.message.guild.getRolesByName(command[1], false)
-                        result.mentionedRole = when {
-                            command[1] == "everyone" -> {
-                                event.message.channel.sendMessage("Now pinging everyone.").queue()
-                                "everyone"
-                            }
-                            command[1] == "none" -> {
-                                event.message.channel.sendMessage("Now pinging none.").queue()
-                                null
-                            }
-                            roles.firstOrNull() != null -> {
-                                event.message.channel.sendMessage("Now pinging ${roles.first().name}").queue()
-                                roles.first().id
-                            }
-                            else -> {
-                                event.message.channel.sendMessage("Unknown role.").queue()
-                                result.mentionedRole
-                            }
-                        }
-                        Channels.saveChannels()
-                    } else {
-                        event.message.channel.sendMessage("Usage: `${prefix}ping [everyone|none|roleName]`")
-                    }
-                } else {
-                    event.message.channel.sendMessage("Channel is not registered.").queue()
-                }
-            }
-            "setMessage" -> {
-                val result = Channels.channels.find { it.id == channelId }
-                if (result != null) {
-                    if (command.size > 1) {
-                        val message = event.message.contentRaw.removePrefix("${prefix}setMessage").trim()
-                        result.message = CustomMessage(message)
-                        Channels.saveChannels()
-                        event.message.channel.sendMessage("Set `$message` as message.").queue()
-                    } else {
-                        event.message.channel.sendMessage("Usage: `${prefix}setMessage [message]`")
-                    }
-                } else {
-                    event.message.channel.sendMessage("Channel is not registered.").queue()
-                }
-            }
-            "resetMessage" -> {
-                val result = Channels.channels.find { it.id == channelId }
-                if (result != null) {
-                    result.message = null
-                    Channels.saveChannels()
-                    event.message.channel.sendMessage("Reset to no message.").queue()
-                } else {
-                    event.message.channel.sendMessage("Channel is not registered.").queue()
-                }
-            }
-            "serviceChannel" -> {
-                if (command.size > 1 && listOf("add", "remove").contains(command[1])) {
-                    if (command[1] == "add") {
-                        if (Channels.serviceChannels.find { it.id == channelId } != null) {
-                            event.message.channel.sendMessage("Already a service channel.").queue()
-                        } else {
-                            Channels.serviceChannels.add(ServiceChannel(channelId))
-                            Channels.saveChannels()
-                            event.message.channel.sendMessage("Added as service channel.").queue()
-                        }
-                    } else {
-                        event.message.channel.sendMessage(
-                            if (Channels.serviceChannels.removeAll { it.id == channelId }) "Channel removed."
-                            else "Not a service channel."
-                        ).queue()
-                    }
-                    Channels.saveChannels()
-                } else {
-                    event.message.channel.sendMessage("Usage: `${prefix}serviceChannel [add|remove]`")
-                }
-
-            }
-            "publishMessage" -> {
-                val result = Channels.channels.find { it.id == channelId }
-                if (result != null) {
-                    if (result.message != null) {
-                        if (command.size > 1 && listOf("on", "off").contains(command[1])) {
-                            result.message?.pushAnnouncement = command[1] == "on"
-                            Channels.saveChannels()
-
-                            event.message.channel.sendMessage("Auto publish (message) is now ${command[1]}").queue()
-                        } else {
-                            event.message.channel.sendMessage("Usage: `${prefix}publishMessage [on|off]`")
-                        }
-                    } else {
-                        event.message.channel.sendMessage("Channel has no custom message.").queue()
-                    }
-                } else {
-                    event.message.channel.sendMessage("Channel not registered.").queue()
-                }
-            }
-            "info" -> {
-                event.message.channel.sendMessage(
-                    EmbedBuilder()
-                        .setTitle("Server overview")
-                        .setColor(Color.GREEN)
-                        .setDescription("""
-                            ${Channels.getServerNames(event.message.guild.idLong).joinToString("\n")}
-                                                
-                            **_Service Channels_**
-                            ${Channels.getServiceChannelServers(event.message.guild.idLong).joinToString("\n")}
-                        """.trimIndent())
-                        .setAuthor(Admin.admin?.name, Admin.admin?.avatarUrl, Admin.admin?.avatarUrl)
-                        .build()
-                ).queue()
-            }
-            "report" -> {
-                val errorReport = event.message.contentRaw.removePrefix("${prefix}report")
-                Admin.error(event.message.guild.name, errorReport, event.author)
-                event.message.channel.sendMessage(
-                    EmbedBuilder()
-                        .setTitle("Error Report Received")
-                        .setColor(Color.RED)
-                        .setDescription(errorReport)
-                        .setAuthor(Admin.admin?.name, Admin.admin?.avatarUrl, Admin.admin?.avatarUrl)
-                        .build()
-                ).queue()
-            }
-            "help" -> {
-                event.message.channel.sendMessage(
-                    EmbedBuilder()
-                        .setTitle("Help")
-                        .setColor(Color.YELLOW)
-                        .setAuthor(Admin.admin?.name, Admin.admin?.avatarUrl, Admin.admin?.avatarUrl)
-                        .setDescription(
-                            """
-                            **${prefix}add**
-                            Add this channel to the notified list
-                            **${prefix}serviceChannel [add|remove]**
-                            Add or remove this channel to receive service message from the bot developer (recommended)
-                            **${prefix}remove**
-                            Remove this channel to the notified list
-                            **${prefix}publish [on|off]**
-                            [Community|Partner|Verified only] Auto publish the message if in an announcement channel
-                            **${prefix}ping [none|everyone|roleName]**
-                            What role to ping
-                            **${prefix}setMessage [message]**
-                            Set a custom message to show
-                            **${prefix}resetMessage**
-                            Reset the message
-                            **${prefix}info**
-                            Show an overview about all channels registered on this server
-                            **${prefix}report**
-                            Report an issue to the Bot Admin (this will share your user name so they can contact you)
-                            **${prefix}help**
-                            Show this message
-                        """.trimIndent()
-                        )
-                        .build()
-                ).queue()
-            }
-        }
-    }
-}

src/main/kotlin/de/wulkanat/cli/AdminCli.kt

@@ -0,0 +1,109 @@
+@file:AutoWired
+
+package de.wulkanat.cli
+
+import com.gitlab.kordlib.core.entity.channel.DmChannel
+import com.gitlab.kordlib.kordx.commands.annotation.AutoWired
+import com.gitlab.kordlib.kordx.commands.argument.primitive.BooleanArgument
+import com.gitlab.kordlib.kordx.commands.argument.text.StringArgument
+import com.gitlab.kordlib.kordx.commands.kord.model.precondition.precondition
+import com.gitlab.kordlib.kordx.commands.kord.model.prefix.kord
+import com.gitlab.kordlib.kordx.commands.kord.model.prefix.mention
+import com.gitlab.kordlib.kordx.commands.kord.model.respondEmbed
+import com.gitlab.kordlib.kordx.commands.kord.module.module
+import com.gitlab.kordlib.kordx.commands.model.command.invoke
+import com.gitlab.kordlib.kordx.commands.model.prefix.literal
+import com.gitlab.kordlib.kordx.commands.model.prefix.or
+import com.gitlab.kordlib.kordx.commands.model.prefix.prefix
+import de.wulkanat.Admin
+import de.wulkanat.extensions.alsoIf
+import de.wulkanat.extensions.isBotAdmin
+import de.wulkanat.files.ServiceChannels
+import de.wulkanat.model.BlogPostPreview
+import de.wulkanat.web.SiteWatcher
+
+val prefixes = prefix {
+    kord { mention() or literal("%!") }
+}
+
+fun adminCommands() = module("admin-commands") {
+    precondition { author.isBotAdmin && channel.asChannelOrNull() is DmChannel }
+
+    command("stop") {
+        invoke {
+            respond("Shutting down...")
+            kord.shutdown()
+        }
+    }
+
+    command("info") {
+        invoke {
+            Admin.info()
+        }
+    }
+
+    command("fakeUpdate") {
+        invoke {
+            respond("THIS WILL CAUSE A MESSAGE ON **ALL** SERVERS.\nContinue? [y/n]")
+            if (read(BooleanArgument(trueValue = "y", falseValue = "n"))) {
+                respond("Sending fake update on next cycle")
+
+                SiteWatcher.newestBlog = BlogPostPreview(
+                    title = "FakePost",
+                    imgUrl = "",
+                    fullPostUrl = "",
+                    author = "wulkanat",
+                    date = "now",
+                    description = "Lorem Ipsum"
+                )
+            } else {
+                respond("Aborting")
+            }
+        }
+    }
+
+    command("serviceMessage") {
+        invoke {
+            respond("What's the title?")
+            val title = read(StringArgument)
+            respond("What's the message?")
+            val message = read(StringArgument)
+            respondEmbed {
+                this.title = title
+                description = message
+                footer {
+                    text = "Is that correct? [y/n]"
+                }
+            }
+            if (read(BooleanArgument(trueValue = "y", falseValue = "n"))) {
+                respond("Sending")
+                ServiceChannels.sendServiceMessage(title, message)
+            } else {
+                respond("Aborting")
+            }
+        }
+    }
+
+    command("refreshList") {
+        invoke {
+            ServiceChannels.channels = ServiceChannels.refreshChannelsFromDisk()
+            ServiceChannels.serviceChannels = ServiceChannels.refreshServiceChannelsFromDisk()
+            Admin.info()
+        }
+    }
+
+    command("removeInactive") {
+        invoke {
+            respondEmbed {
+                title = "Channels removed"
+
+                ServiceChannels.channels.removeAll { channel ->
+                    (ServiceChannels.testServerId(channel.id) == null).alsoIf(true) {
+                        field { name = channel.id.toString() }
+                    }
+                }
+            }
+            ServiceChannels.saveChannels()
+        }
+    }
+}

src/main/kotlin/de/wulkanat/cli/OwnerCli.kt

@@ -0,0 +1,159 @@
+@file:AutoWired
+
+package de.wulkanat.cli
+
+import com.gitlab.kordlib.common.entity.Permission
+import com.gitlab.kordlib.kordx.commands.annotation.AutoWired
+import com.gitlab.kordlib.kordx.commands.argument.primitive.BooleanArgument
+import com.gitlab.kordlib.kordx.commands.argument.text.StringArgument
+import com.gitlab.kordlib.kordx.commands.kord.argument.RoleArgument
+import com.gitlab.kordlib.kordx.commands.kord.model.precondition.precondition
+import com.gitlab.kordlib.kordx.commands.kord.model.respondEmbed
+import com.gitlab.kordlib.kordx.commands.kord.module.module
+import com.gitlab.kordlib.kordx.commands.model.command.invoke
+import de.wulkanat.Admin
+import de.wulkanat.CustomMessage
+import de.wulkanat.ServiceChannel
+import de.wulkanat.files.ServiceChannels
+import java.awt.Color
+
+// TODO: channel argument?
+fun ownerCommands() = module("owner-commands") {
+    precondition {
+        message.getAuthorAsMember()?.getPermissions()?.contains(Permission.Administrator) ?: false
+    }
+
+    command("add") {
+        invoke {
+            if (ServiceChannels.addChannel(channel.id.longValue, null) == null) {
+                respond("Already added.")
+            } else {
+                respond("Added.")
+                Admin.info()
+            }
+        }
+    }
+
+    command("remove") {
+        invoke {
+            val result = ServiceChannels.channels.removeAll { it.id == channel.id.longValue }
+            ServiceChannels.saveChannels()
+            if (result) {
+                respond("Removed.")
+            } else {
+                respond("This channel is not registered.")
+            }
+        }
+    }
+
+    command("publish") {
+        invoke(BooleanArgument(trueValue = "on", falseValue = "off")) { doAutoPublish ->
+            ServiceChannels.channels.find { it.id == channel.id.longValue }?.also {
+                it.autoPublish = doAutoPublish
+                ServiceChannels.saveChannels()
+            } ?: respond("Channel not registered")
+        }
+    }
+
+    command("ping") {
+        invoke(RoleArgument) { role ->
+            ServiceChannels.channels.find { it.id == channel.id.longValue }?.also {
+                // TODO: @everyone
+                it.mentionedRole = role.id.longValue
+                ServiceChannels.saveChannels()
+            } ?: respond("Channel not registered")
+        }
+    }
+
+    command("setMessage") {
+        invoke(StringArgument) { message ->
+            ServiceChannels.channels.find { it.id == channel.id.longValue}?.also {
+                it.message = CustomMessage(message)
+                respond("Set `$message` as a message.")
+            } ?: respond("Channel not registered!")
+        }
+    }
+
+    command("resetMessage") {
+        invoke {
+            ServiceChannels.channels.find { it.id == channel.id.longValue }?.also {
+                it.message = null
+                respond("Reset to no message")
+            } ?: respond("Channel not registered!")
+        }
+    }
+
+    command("serviceChannel") {
+        invoke(BooleanArgument(trueValue = "add", falseValue = "remove")) { addChannel ->
+            if (addChannel) {
+                ServiceChannels.serviceChannels.find { it.id == channel.id.longValue }?.also {
+                    respond("Already a service channel")
+                } ?: run {
+                    ServiceChannels.serviceChannels.add(ServiceChannel(channel.id.longValue))
+                    respond("Added as a service channel")
+                }
+            } else {
+                respond(if (ServiceChannels.serviceChannels.removeAll { it.id == channel.id.longValue })
+                    "Channel removed" else "Not a service channel")
+            }
+        }
+    }
+
+    command("publishMessage") {
+        invoke(BooleanArgument(trueValue = "on", falseValue = "off")) { doAutoPublish ->
+            ServiceChannels.channels.find { it.id == channel.id.longValue }?.also {
+                it.message?.pushAnnouncement = doAutoPublish
+                ServiceChannels.saveChannels()
+                respond("Auto publish is now ${if (doAutoPublish) "on" else "off"}")
+            } ?: respond("Channel not registered!")
+        }
+    }
+
+    command("info") {
+        invoke {
+            respondEmbed {
+                title = "Server Overview"
+                color = Color.GREEN
+                description = """
+                    ${ServiceChannels.getServerNames(guild?.id?.longValue).joinToString("\n")}
+                    
+                    **_Service Channels_**
+                    ${ServiceChannels.getServiceChannelServers(guild?.id?.longValue).joinToString("\n")}
+                """.trimIndent()
+                Admin.admin?.let {
+                    author {
+                        name = it.username
+                        icon = it.avatar.url
+                        url = "https://github.com/wulkanat/BlogShot"
+                    }
+                }
+            }
+        }
+    }
+
+    command("report") {
+        invoke {
+            respond("What is the error you encountered?")
+            val errorReport = read(StringArgument)
+            respondEmbed {
+                title = "Error Report Preview"
+                color = Color.RED
+                description = errorReport
+                message.author?.let {
+                    author {
+                        name = it.username
+                        icon = it.avatar.url
+                    }
+                }
+
+            }
+            respond("Send? [y/n]")
+            if (read(BooleanArgument(trueValue = "y", falseValue = "n"))) {
+                respond("Sent")
+                Admin.error(guild?.asGuildOrNull()?.name ?: "Unknown Guild", errorReport, author)
+            } else {
+                respond("Aborting")
+            }
+        }
+    }
+}

src/main/kotlin/de/wulkanat/extensions/Generic.kt

@@ -0,0 +1,8 @@
+package de.wulkanat.extensions
+
+inline fun <T> Boolean.alsoIf(other: T, body: () -> Unit): Boolean {
+    if (this == other) {
+        body()
+    }
+    return this
+}

src/main/kotlin/de/wulkanat/extensions/User.kt

@@ -0,0 +1,7 @@
+package de.wulkanat.extensions
+
+import com.gitlab.kordlib.core.entity.User
+import de.wulkanat.files.Config
+
+val User.isBotAdmin: Boolean
+    get() = id.longValue == Config.adminId

src/main/kotlin/de/wulkanat/files/Config.kt

@@ -0,0 +1,26 @@
+package de.wulkanat.files
+
+import de.wulkanat.files.concept.SerializableObject
+import kotlinx.serialization.Serializable
+
+object Config : SerializableObject<Config.Data>("config.json", Data(), Data.serializer()) {
+    val adminId: Long
+        get() = instance.adminId
+    val token: String
+        get() = instance.token
+    val updateMs: Long
+        get() = instance.updateMs
+    val watchingMessage: String
+        get() = instance.watchingMessage
+    val offlineMessage: String
+        get() = instance.offlineMessage
+
+    @Serializable
+    data class Data(
+        val adminId: Long = 12345,
+        val token: String = "12345",
+        val updateMs: Long = 30000,
+        val watchingMessage: String = "for new Blogposts",
+        val offlineMessage: String = "CONNECTION FAILED"
+    )
+}

src/main/kotlin/de/wulkanat/files/Servers.kt

@@ -0,0 +1,4 @@
+package de.wulkanat.files
+
+object Servers {
+}

src/main/kotlin/de/wulkanat/files/ServiceChannels.kt

@@ -1,6 +1,9 @@
-package de.wulkanat
+package de.wulkanat.files
 
-import de.wulkanat.extensions.crosspost
+import com.gitlab.kordlib.core.Kord
+import com.gitlab.kordlib.core.entity.Embed
+import com.gitlab.kordlib.rest.builder.message.EmbedBuilder
+import de.wulkanat.*
 import kotlinx.serialization.list
 import net.dv8tion.jda.api.EmbedBuilder
 import net.dv8tion.jda.api.JDA
@@ -9,8 +12,8 @@ import net.dv8tion.jda.api.entities.MessageEmbed
 import net.dv8tion.jda.api.entities.TextChannel
 import java.awt.Color
 
-object Channels {
+object ServiceChannels {
-    var jda: JDA? = null
+    var client: Kord? = null
 
     /**
      * List of (ServerID, ChannelID)
@@ -18,13 +21,13 @@ object Channels {
     var channels: MutableList<DiscordChannel> = refreshChannelsFromDisk()
     var serviceChannels: MutableList<ServiceChannel> = refreshServiceChannelsFromDisk()
 
-    fun sentToAll(messageEmbed: MessageEmbed) {
+    fun sentToAll(messageEmbed: Embed) {
-        if (jda == null)
+        if (client == null)
             return
 
         for (channel_pair in channels) {
             try {
-                val channel = jda!!.getTextChannelById(channel_pair.id) ?: continue
+                val channel = client!!.getTextChannelById(channel_pair.id) ?: continue
                 val customMessage = channel_pair.message?.message ?: ""
 
                 if (channel_pair.mentionedRole != null) {
@@ -66,13 +69,14 @@ object Channels {
             .build()
 
         for (channelInfo in serviceChannels) {
-            val channel = jda!!.getTextChannelById(channelInfo.id)
+            val channel = client!!.getTextChannelById(channelInfo.id)
 
             channel?.sendMessage(serviceMessage)?.queue()
         }
 
         Admin.println("Service message distributed to ${serviceChannels.size} channels.")
-        Admin.sendDevMessage(serviceMessage, """
+        Admin.sendDevMessage(
+            serviceMessage, """
             ***************
             SERVICE MESSAGE
             
@@ -80,12 +84,13 @@ object Channels {
             -------
             $message
             ***************
-        """.trimIndent())
+        """.trimIndent()
+        )
     }
 
     fun checkEveryonePermission() {
         for (channel_pair in channels) {
-            val channel = jda!!.getTextChannelById(channel_pair.id) ?: continue
+            val channel = client!!.getTextChannelById(channel_pair.id) ?: continue
 
             if (channel_pair.mentionedRole == "everyone" &&
                 channel.guild.selfMember.hasPermission(Permission.MESSAGE_MENTION_EVERYONE)
@@ -111,11 +116,11 @@ object Channels {
     }
 
     fun getServerNames(server: Long? = null): List<String> {
-        if (jda == null)
+        if (client == null)
             return listOf()
 
-        return channels.filter { server == null || (jda!!.getTextChannelById(it.id)?.guild?.idLong == server) }.map {
+        return channels.filter { server == null || (client!!.getTextChannelById(it.id)?.guild?.idLong == server) }.map {
-            val channel = jda!!.getTextChannelById(it.id)
+            val channel = client!!.getTextChannelById(it.id)
             if (channel == null) {
                 Admin.warning("Channel ${it.id} is no longer active!")
                 return@map "**${it.id}** *(inactive)*"
@@ -137,17 +142,17 @@ object Channels {
     }
 
     fun getServiceChannelServers(server: Long? = null): List<String> {
-        if (jda == null)
+        if (client == null)
             return listOf()
 
-        return serviceChannels.filter { server == null || (jda!!.getTextChannelById(it.id)?.guild?.idLong == server) }.map {
+        return serviceChannels.filter { server == null || (client!!.getTextChannelById(it.id)?.guild?.idLong == server) }.map {
-            val channel = jda!!.getTextChannelById(it.id)
+            val channel = client!!.getTextChannelById(it.id)
             "**${channel?.guild?.name ?: it.id}** #${channel?.name ?: "(inactive)"}"
         }
     }
 
     fun testServerId(id: Long): TextChannel? {
-        return jda?.getTextChannelById(id)
+        return client?.getTextChannelById(id)
     }
 
     fun addChannel(id: Long, role: String?): DiscordChannel? {

src/main/kotlin/de/wulkanat/files/concept/SerializableObject.kt

@@ -0,0 +1,24 @@
+package de.wulkanat.files.concept
+
+import de.wulkanat.extensions.ensureExists
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.json.Json
+import java.io.File
+
+abstract class SerializableObject<T>(
+    fileName: String,
+    defaultText: T? = null,
+    private val childSerializer: KSerializer<T>
+) {
+    private val json = Json { allowStructuredMapKeys = true }
+    private val file = File(fileName).ensureExists(defaultText?.let { json.encodeToString(childSerializer, it) })
+    var instance: T = json.decodeFromString(childSerializer, file.readText())
+
+    fun refresh() {
+        instance = json.decodeFromString(childSerializer, file.readText())
+    }
+
+    fun save() {
+        file.writeText(json.encodeToString(childSerializer, instance))
+    }
+}

src/main/kotlin/de/wulkanat/web/SiteWatcher.kt

@@ -3,6 +3,8 @@ package de.wulkanat.web
 import de.wulkanat.Admin
 import de.wulkanat.DiscordRpc
 import de.wulkanat.model.BlogPostPreview
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
 import org.jsoup.Jsoup
 import java.io.IOException
 
@@ -11,9 +13,14 @@ object SiteWatcher {
     var newestBlog: BlogPostPreview? = null
     private var siteOnline = false
 
-    fun hasNewBlogPost(): Boolean {
+    suspend fun hasNewBlogPost(): Boolean {
         try {
-            val doc = Jsoup.connect(BLOG_INDEX_URL).get()
+            val doc = withContext(Dispatchers.IO) {
+                // solved by `withContext`
+                // https://stackoverflow.com/a/63332658
+                @Suppress("BlockingMethodInNonBlockingContext")
+                Jsoup.connect(BLOG_INDEX_URL).get()
+            }
             val newBlog = BlogPostParser.getFistBlog(doc)
 
             if (newestBlog == newBlog) {