Fix automatic chapter downloads (#2098)

The returned result rows of the inserted chapters did not have the up-to-date "last_modified_at".
This caused "downloadNewChapters" to not be able to correctly detect unread chapters. it included the newly inserted ones, leading to exiting early due to having unread chapters.

Regression 811e15162b

fixes #2097

.editorconfig

@@ -11,4 +11,8 @@ ktlint_standard_if-else-wrapping=disabled
 ktlint_standard_no-consecutive-comments=disabled
 
 [**/generated/**]
-ktlint=disabled
+ktlint=disabled
+
+[*.json]
+indent_size=2
+indent_style = space

.github/workflows/build_pull_request.yml

@@ -67,7 +67,7 @@ jobs:
           export LD_PRELOAD="$(pwd)/scripts/resources/catch_abort.so"
           JAR=$(ls ./server/build/*.jar| head -1)
           set +e
-          timeout 30s java -DcrashOnFailedMigration=true \
+          timeout 30s java \
               -Dsuwayomi.tachidesk.config.server.systemTrayEnabled=false \
               -Dsuwayomi.tachidesk.config.server.initialOpenInBrowserEnabled=false \
               -Dsuwayomi.tachidesk.config.server.databaseType=POSTGRESQL \
@@ -83,7 +83,7 @@ jobs:
             exit "$ecode"
           fi
 
-          timeout 30s java -DcrashOnFailedMigration=true \
+          timeout 30s java \
               -Dsuwayomi.tachidesk.config.server.systemTrayEnabled=false \
               -Dsuwayomi.tachidesk.config.server.initialOpenInBrowserEnabled=false \
               -jar "$JAR"
@@ -96,6 +96,10 @@ jobs:
           fi
           exit 0
 
+      - name: "Run tests"
+        working-directory: master
+        run: ./gradlew test --stacktrace
+
   check_docs:
     name: Validate that all options are documented
     runs-on: ubuntu-latest

.github/workflows/wiki.yml

@@ -1,6 +1,7 @@
 name: GitHub Wiki upload
 
 on:
+  workflow_dispatch:
   push:
     branches:
       - master
@@ -23,6 +24,8 @@ jobs:
         with:
           repository: ${{github.repository}}
           path: ${{github.repository}}
+          fetch-depth: 0 # fetch history & tags to determine stable version
+          fetch-tags: true
 
       - name: Checkout Wiki
         uses: actions/checkout@v6
@@ -35,6 +38,13 @@ jobs:
           set -e
           cd $GITHUB_WORKSPACE/${{github.repository}}.wiki
           cp -r $GITHUB_WORKSPACE/${{github.repository}}/docs/* .
+          
+          stable="$(git -C $GITHUB_WORKSPACE/${{github.repository}} describe --abbrev=0 --tags)"
+          if ! git -C $GITHUB_WORKSPACE/${{github.repository}} log --exit-code --pretty= "$stable.." -- docs/Configuring-Suwayomi‐Server.md; then
+            echo "Changes to config detected, embedding link to stable"
+            sed -i '1s/^/> [!WARNING]\n> This document describes the settings available in the preview version. Please head to ['$stable'](https:\/\/github.com\/Suwayomi\/Suwayomi-Server\/blob\/'$stable'\/docs\/Configuring-Suwayomi%E2%80%90Server.md) for the current stable version\n\n/' Configuring-Suwayomi‐Server.md
+          fi
+          
           git config --local user.email "action@github.com"
           git config --local user.name "GitHub Action"
           git add .

AndroidCompat/src/main/java/xyz/nulldev/androidcompat/webkit/CefHelper.kt

@@ -0,0 +1,47 @@
+package xyz.nulldev.androidcompat.webkit
+
+import io.github.oshai.kotlinlogging.KotlinLogging
+import kotlinx.coroutines.channels.awaitClose
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.callbackFlow
+import kotlinx.coroutines.flow.first
+import org.cef.CefApp
+import org.cef.CefClient
+
+private val logger = KotlinLogging.logger {}
+
+object CefHelper {
+    val cefApp = MutableStateFlow<Result<CefApp?>>(Result.success(null))
+
+    suspend fun createClient(): CefClient {
+        val app = waitForInit().first()
+        val client = app.createClient()
+        JsHandler(client) // This adds itself to a global map
+        return client
+    }
+
+    fun waitForInit() =
+        callbackFlow<CefApp> {
+            val app = cefApp.first { it.isFailure || it.getOrThrow() != null }.getOrThrow()!!
+            app.onInitialization {
+                logger.debug { "CEF: Initialization state $it" }
+                when (it) {
+                    CefApp.CefAppState.INITIALIZED -> {
+                        trySend(app)
+                        close()
+                    }
+
+                    CefApp.CefAppState.SHUTTING_DOWN, CefApp.CefAppState.TERMINATED -> {
+                        close(CefException("Shutting down"))
+                    }
+
+                    else -> {}
+                }
+            }
+            awaitClose {}
+        }
+
+    class CefException(
+        msg: String,
+    ) : Exception(msg)
+}

AndroidCompat/src/main/java/xyz/nulldev/androidcompat/webkit/KcefHelper.kt

@@ -0,0 +1,136 @@
+package xyz.nulldev.androidcompat.webkit
+
+import io.github.oshai.kotlinlogging.KotlinLogging
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
+import org.cef.CefClient
+import org.cef.browser.CefBrowser
+import org.cef.browser.CefFrame
+import org.cef.browser.CefMessageRouter
+import org.cef.callback.CefQueryCallback
+import org.cef.handler.CefMessageRouterHandlerAdapter
+import kotlin.random.Random
+
+private val logger = KotlinLogging.logger {}
+private val jsHandler: MutableMap<CefClient, JsHandler> = mutableMapOf()
+
+fun CefBrowser.evaluateJavaScript(
+    expression: String,
+    cb: (String?) -> Unit,
+) = jsHandler[this.client]!!.eval(this, expression, cb)
+
+fun CefBrowser.dispose() {
+    stopLoad()
+    setCloseAllowed()
+    close(true)
+}
+
+class JsHandler : CefMessageRouterHandlerAdapter {
+    private val handler: MutableMap<String, (String?) -> Unit> = mutableMapOf()
+
+    constructor(client: CefClient) {
+        val config = CefMessageRouter.CefMessageRouterConfig()
+        config.jsQueryFunction = QUERY_FN
+        config.jsCancelFunction = QUERY_CANCEL_FN
+        client.addMessageRouter(CefMessageRouter.create(config, this))
+        jsHandler[client] = this
+    }
+
+    fun eval(
+        frame: CefFrame,
+        expression: String,
+        cb: (String?) -> Unit,
+    ) {
+        val id = Random.nextBytes(48).toHexString()
+        handler[id] = cb
+        frame.executeJavaScript(expression.toCode(id), "about:cef", 0)
+    }
+
+    fun eval(
+        browser: CefBrowser,
+        expression: String,
+        cb: (String?) -> Unit,
+    ) {
+        val id = Random.nextBytes(48).toHexString()
+        handler[id] = cb
+        browser.executeJavaScript(expression.toCode(id), "about:cef", 0)
+    }
+
+    override fun onQuery(
+        browser: CefBrowser?,
+        frame: CefFrame?,
+        queryId: Long,
+        request: String?,
+        persistent: Boolean,
+        callback: CefQueryCallback?,
+    ): Boolean {
+        super.onQuery(browser, frame, queryId, request, persistent, callback)
+
+        if (request != null) {
+            val invoke =
+                try {
+                    Json.decodeFromString<FunctionCall>(request)
+                } catch (e: Exception) {
+                    logger.warn(e) { "Invalid request received" }
+                    return false
+                }
+            val handler = handler.remove(invoke.id) ?: return false
+            handler(invoke.result)
+            callback?.success("")
+            return true
+        }
+
+        return false
+    }
+
+    @Serializable
+    private data class FunctionCall(
+        val id: String,
+        val result: String? = null,
+    )
+
+    companion object {
+        const val QUERY_FN = "__\$_evalQuery"
+        const val QUERY_CANCEL_FN = "__\$_evalQueryCancel"
+
+        private fun Char.isLineBreak(): Boolean = this == '\n' || this == '\r'
+
+        private fun String.containsLineBreak(): Boolean =
+            this.any {
+                it.isLineBreak()
+            }
+
+        private fun String.asFunctionBody(): String =
+            let { expression ->
+                when {
+                    expression.containsLineBreak() -> expression
+                    expression.trim().startsWith("return", false) -> expression
+                    else -> "return $expression"
+                }
+            }
+
+        private fun String.toCode(id: String): String =
+            """
+            function payload() {
+              ${this.asFunctionBody()}
+            }
+
+            try {
+              var result = payload();
+
+              window.${QUERY_FN}({
+                  request: JSON.stringify({ id: "$id", result }),
+                  onSuccess: function (response) {},
+                  onFailure: function (error_code, error_message) {}
+              });
+            } catch (e) {
+              console.error("Failed to eval $id", e)
+              window.${QUERY_CANCEL_FN}({
+                  request: JSON.stringify({ id: "$id", error: ""+e }),
+                  onSuccess: function (response) {},
+                  onFailure: function (error_code, error_message) {}
+              });
+            }
+            """.trimIndent()
+    }
+}

AndroidCompat/src/main/java/xyz/nulldev/androidcompat/webkit/KcefWebViewProvider.kt

@@ -51,11 +51,10 @@ import android.webkit.WebViewProvider.ScrollDelegate
 import android.webkit.WebViewProvider.ViewDelegate
 import android.webkit.WebViewRenderProcess
 import android.webkit.WebViewRenderProcessClient
-import dev.datlag.kcef.KCEF
-import dev.datlag.kcef.KCEFBrowser
-import dev.datlag.kcef.KCEFClient
+import kotlinx.coroutines.runBlocking
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.json.Json
+import org.cef.CefClient
 import org.cef.CefSettings
 import org.cef.browser.CefBrowser
 import org.cef.browser.CefFrame
@@ -69,6 +68,7 @@ import org.cef.handler.CefLoadHandler
 import org.cef.handler.CefLoadHandlerAdapter
 import org.cef.handler.CefMessageRouterHandlerAdapter
 import org.cef.handler.CefPermissionHandler
+import org.cef.handler.CefRenderHandlerAdapter
 import org.cef.handler.CefRequestHandler
 import org.cef.handler.CefRequestHandlerAdapter
 import org.cef.handler.CefResourceHandler
@@ -83,11 +83,14 @@ import org.cef.network.CefPostDataElement
 import org.cef.network.CefRequest
 import org.cef.network.CefResponse
 import org.koin.mp.KoinPlatformTools
+import java.awt.Rectangle
 import java.io.BufferedWriter
 import java.io.File
 import java.io.IOException
+import java.nio.ByteBuffer
 import java.util.concurrent.Executor
-import kotlin.reflect.KClass
+import javax.swing.JPanel
+import kotlin.math.min
 import kotlin.reflect.KFunction
 import kotlin.reflect.full.declaredMemberFunctions
 import kotlin.reflect.jvm.javaMethod
@@ -98,12 +101,13 @@ class KcefWebViewProvider(
     private val settings = KcefWebSettings()
     private var viewClient = WebViewClient()
     private var chromeClient = WebChromeClient()
+    private val renderHandler = RenderHandler()
     private val mappings: MutableList<FunctionMapping> = mutableListOf()
     private val urlHttpMapping: MutableMap<String, String> = mutableMapOf()
     private var initialRequestData: InitialRequestData? = null
 
-    private var kcefClient: KCEFClient? = null
-    private var browser: KCEFBrowser? = null
+    private var kcefClient: CefClient? = null
+    private var browser: CefBrowser? = null
 
     private val handler = Handler(view.webViewLooper)
 
@@ -115,8 +119,8 @@ class KcefWebViewProvider(
         private val initHandler: InitBrowserHandler by KoinPlatformTools.defaultContext().get().inject()
     }
 
-    public interface InitBrowserHandler {
-        public fun init(provider: KcefWebViewProvider): Unit
+    interface InitBrowserHandler {
+        fun init(provider: KcefWebViewProvider): Unit
     }
 
     private data class InitialRequestData(
@@ -192,7 +196,7 @@ class KcefWebViewProvider(
         }
     }
 
-    private inner class DisplayHandler : CefDisplayHandlerAdapter() {
+    private class DisplayHandler : CefDisplayHandlerAdapter() {
         override fun onConsoleMessage(
             browser: CefBrowser,
             level: CefSettings.LogSeverity,
@@ -220,6 +224,7 @@ class KcefWebViewProvider(
         }
     }
 
+    @Suppress("DEPRECATION")
     private inner class LoadHandler : CefLoadHandlerAdapter() {
         override fun onLoadEnd(
             browser: CefBrowser,
@@ -366,7 +371,7 @@ class KcefWebViewProvider(
             callback: CefCallback,
         ): Boolean {
             val data = resolvedData ?: return false
-            val bytesToTransfer = Math.min(bytesToRead, data.size - readOffset)
+            val bytesToTransfer = min(bytesToRead, data.size - readOffset)
             Log.v(
                 TAG,
                 "readResponse: $readOffset/${data.size}, reading $bytesToRead->$bytesToTransfer",
@@ -378,7 +383,7 @@ class KcefWebViewProvider(
         }
     }
 
-    private inner class WebResponseResourceHandler(
+    private class WebResponseResourceHandler(
         val webResponse: WebResourceResponse,
     ) : ArrayResponseResourceHandler() {
         override fun processRequest(
@@ -408,7 +413,7 @@ class KcefWebViewProvider(
         }
     }
 
-    private inner class HtmlResponseResourceHandler(
+    private class HtmlResponseResourceHandler(
         val html: String,
     ) : ArrayResponseResourceHandler() {
         override fun processRequest(
@@ -439,7 +444,7 @@ class KcefWebViewProvider(
                     view,
                     CefWebResourceRequest(request, frame, false),
                 )
-            Log.v(TAG, "Resource ${request?.url}, result is cancel? $cancel")
+            Log.v(TAG, "Resource ${request.url}, result is cancel? $cancel")
 
             handler.post { viewClient.onLoadResource(view, frame?.url) }
 
@@ -466,7 +471,7 @@ class KcefWebViewProvider(
                 }
             if (response == null) {
                 // prefer user's response override
-                urlHttpMapping.get(request.url.trimEnd('/'))?.let {
+                urlHttpMapping[request.url.trimEnd('/')]?.let {
                     return HtmlResponseResourceHandler(it)
                 }
             }
@@ -475,6 +480,7 @@ class KcefWebViewProvider(
         }
     }
 
+    @Suppress("DEPRECATION")
     private inner class RequestHandler : CefRequestHandlerAdapter() {
         override fun getResourceRequestHandler(
             browser: CefBrowser,
@@ -484,11 +490,13 @@ class KcefWebViewProvider(
             isDownload: Boolean,
             requestInitiator: String,
             disableDefaultHandling: BoolRef,
-        ): CefResourceRequestHandler? = ResourceRequestHandler()
+        ): CefResourceRequestHandler = ResourceRequestHandler()
 
         override fun onRenderProcessTerminated(
             browser: CefBrowser,
             status: CefRequestHandler.TerminationStatus,
+            errorCode: Int,
+            errorString: String,
         ) {
             handler.post {
                 viewClient.onRenderProcessGone(
@@ -507,18 +515,33 @@ class KcefWebViewProvider(
         override fun onRequestMediaAccessPermission(
             browser: CefBrowser,
             frame: CefFrame,
-            requesting_url: String,
-            requested_permissions: Int,
+            requestingUrl: String,
+            requestedPermissions: Int,
             callback: CefMediaAccessCallback,
         ): Boolean {
             handler.post {
-                Log.v(TAG, "Checking permission for $requesting_url: $requested_permissions")
-                chromeClient.onPermissionRequest(CefPermissionRequest(requesting_url, requested_permissions, callback))
+                Log.v(TAG, "Checking permission for $requestingUrl: $requestedPermissions")
+                chromeClient.onPermissionRequest(CefPermissionRequest(requestingUrl, requestedPermissions, callback))
             }
             return true
         }
     }
 
+    private class RenderHandler : CefRenderHandlerAdapter() {
+        override fun getViewRect(browser: CefBrowser): Rectangle = Rectangle(0, 0, 1280, 2856)
+
+        override fun onPaint(
+            browser: CefBrowser,
+            popup: Boolean,
+            dirtyRects: Array<Rectangle>,
+            buffer: ByteBuffer,
+            width: Int,
+            height: Int,
+        ) {
+            // do nothing
+        }
+    }
+
     override fun init(
         javaScriptInterfaces: Map<String, Any>?,
         privateBrowsing: Boolean,
@@ -526,16 +549,18 @@ class KcefWebViewProvider(
         Log.v(TAG, "KcefWebViewProvider: initialize")
         destroy()
         kcefClient =
-            KCEF.newClientBlocking().apply {
-                addDisplayHandler(DisplayHandler())
-                addLoadHandler(LoadHandler())
-                addRequestHandler(RequestHandler())
-                addPermissionHandler(PermissionHandler())
+            runBlocking {
+                CefHelper.createClient().apply {
+                    addDisplayHandler(DisplayHandler())
+                    addLoadHandler(LoadHandler())
+                    addRequestHandler(RequestHandler())
+                    addPermissionHandler(PermissionHandler())
 
-                val config = CefMessageRouter.CefMessageRouterConfig()
-                config.jsQueryFunction = QUERY_FN
-                config.jsCancelFunction = QUERY_CANCEL_FN
-                addMessageRouter(CefMessageRouter.create(config, MessageRouterHandler()))
+                    val config = CefMessageRouter.CefMessageRouterConfig()
+                    config.jsQueryFunction = QUERY_FN
+                    config.jsCancelFunction = QUERY_CANCEL_FN
+                    addMessageRouter(CefMessageRouter.create(config, MessageRouterHandler()))
+                }
             }
         initHandler.init(this)
     }
@@ -612,7 +637,8 @@ class KcefWebViewProvider(
             kcefClient!!
                 .createBrowser(
                     loadUrl,
-                    CefRendering.OFFSCREEN,
+                    CefRendering.CefRenderingWithHandler(renderHandler, JPanel()),
+                    false,
                 ).apply {
                     // NOTE: Without this, we don't seem to be receiving any events
                     createImmediately()
@@ -636,7 +662,8 @@ class KcefWebViewProvider(
             kcefClient!!
                 .createBrowser(
                     url,
-                    CefRendering.OFFSCREEN,
+                    CefRendering.CefRenderingWithHandler(renderHandler, JPanel()),
+                    false,
                 ).apply {
                     // NOTE: Without this, we don't seem to be receiving any events
                     createImmediately()
@@ -662,27 +689,19 @@ class KcefWebViewProvider(
         browser?.close(true)
         browser?.dispose()
         chromeClient.onProgressChanged(view, 0)
+        val url = baseUrl ?: "about:blank"
+        urlHttpMapping[url.trimEnd('/')] = data
 
         browser =
-            (
-                baseUrl?.let { url ->
-                    urlHttpMapping.put(url.trimEnd('/'), data)
-                    kcefClient!!.createBrowser(
-                        url,
-                        CefRendering.OFFSCREEN,
-                    )
+            kcefClient!!
+                .createBrowser(
+                    url,
+                    CefRendering.CefRenderingWithHandler(renderHandler, JPanel()),
+                    false,
+                ).apply {
+                    // NOTE: Without this, we don't seem to be receiving any events
+                    createImmediately()
                 }
-                    ?: run {
-                        kcefClient!!.createBrowserWithHtml(
-                            data,
-                            KCEFBrowser.BLANK_URI,
-                            CefRendering.OFFSCREEN,
-                        )
-                    }
-            ).apply {
-                // NOTE: Without this, we don't seem to be receiving any events
-                createImmediately()
-            }
         Log.d(TAG, "Page loaded from data at base URL $baseUrl")
     }
 
@@ -692,11 +711,11 @@ class KcefWebViewProvider(
     ) {
         browser!!.evaluateJavaScript(
             script.removePrefix("javascript:"),
+        )
             {
                 Log.v(TAG, "JS returned: $it")
                 it?.let { handler.post { resultCallback?.onReceiveValue(it) } }
-            },
-        )
+            }
     }
 
     override fun saveWebArchive(filename: String): Unit = throw RuntimeException("Stub!")
@@ -776,15 +795,23 @@ class KcefWebViewProvider(
 
     override fun getContentWidth(): Int = throw RuntimeException("Stub!")
 
-    override fun pauseTimers(): Unit = throw RuntimeException("Stub!")
+    override fun pauseTimers() {
+        Log.v(TAG, "pauseTimers: doing nothing")
+    }
 
-    override fun resumeTimers(): Unit = throw RuntimeException("Stub!")
+    override fun resumeTimers() {
+        Log.v(TAG, "resumeTimers: doing nothing")
+    }
 
-    override fun onPause(): Unit = throw RuntimeException("Stub!")
+    override fun onPause() {
+        Log.v(TAG, "onPause: doing nothing")
+    }
 
-    override fun onResume(): Unit = throw RuntimeException("Stub!")
+    override fun onResume() {
+        Log.v(TAG, "onResume: doing nothing")
+    }
 
-    override fun isPaused(): Boolean = throw RuntimeException("Stub!")
+    override fun isPaused(): Boolean = false
 
     override fun freeMemory(): Unit = throw RuntimeException("Stub!")
 
@@ -838,6 +865,7 @@ class KcefWebViewProvider(
 
     override fun getWebChromeClient(): WebChromeClient = chromeClient
 
+    @Suppress("DEPRECATION")
     override fun setPictureListener(listener: PictureListener): Unit = throw RuntimeException("Stub!")
 
     @Serializable
@@ -860,7 +888,7 @@ class KcefWebViewProvider(
         obj: Any,
         interfaceName: String,
     ) {
-        val cls = obj::class as KClass<Any>
+        val cls = obj::class
         mappings.addAll(
             cls.declaredMemberFunctions.map {
                 // This is ridiculous, but necessary, otherwise "public final" throws
@@ -922,7 +950,8 @@ class KcefWebViewProvider(
     override fun getRendererPriorityWaivedWhenNotVisible(): Boolean = throw RuntimeException("Stub!")
 
     @SuppressWarnings("unused")
-    override fun setTextClassifier(textClassifier: TextClassifier?) {}
+    override fun setTextClassifier(textClassifier: TextClassifier?) {
+    }
 
     override fun getTextClassifier(): TextClassifier = TextClassifier.NO_OP
 
@@ -948,11 +977,13 @@ class KcefWebViewProvider(
         override fun onProvideAutofillVirtualStructure(
             @SuppressWarnings("unused") structure: android.view.ViewStructure,
             @SuppressWarnings("unused") flags: Int,
-        ) {}
+        ) {
+        }
 
         override fun autofill(
             @SuppressWarnings("unused") values: SparseArray<AutofillValue>,
-        ) {}
+        ) {
+        }
 
         override fun isVisibleToUserForAutofill(
             @SuppressWarnings("unused") virtualId: Int,
@@ -963,7 +994,8 @@ class KcefWebViewProvider(
         override fun onProvideContentCaptureStructure(
             @SuppressWarnings("unused") structure: android.view.ViewStructure,
             @SuppressWarnings("unused") flags: Int,
-        ) {}
+        ) {
+        }
 
         override fun getAccessibilityNodeProvider(): AccessibilityNodeProvider = throw RuntimeException("Stub!")
 
@@ -1033,7 +1065,8 @@ class KcefWebViewProvider(
         override fun onMovedToDisplay(
             displayId: Int,
             config: Configuration,
-        ) {}
+        ) {
+        }
 
         override fun onVisibilityChanged(
             changedView: View,

CHANGELOG.md

@@ -7,16 +7,28 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 ## [Unreleased] (Preview)
 
 ### Added
-- .
+- (**Sync**) Added [SyncYomi](https://github.com/syncyomi/syncyomi) support
 
 ### Changed
-- .
+- (**Database/H2**) Use the latest H2 database engine
+- (**Startup**) Crash on startup if an unrecoverable error happens
+- (**WebView**) Use JCEF directly and update to newest Chromium
+- (**Extension/Android**) Switch MessageQueue to LegacyMessageQueue from ConcurrentMessageQueue
 
 ### Fixed
-- (CloudFlareInterceptor) Don't send the `cf_clearance` cookie back to Flaresolverr
-- (WebUI) Handle serving non-default webui with "bundled"
-- (WebUI) Wait until WebUI is ready to open in browser
-- (Downloads) Truncate filenames by byte length to prevent "File name too long" IO errors
+- (**CloudFlareInterceptor**) Don't send the `cf_clearance` cookie back to Flaresolverr
+- (**WebUI**) Handle serving non-default webui with "bundled"
+- (**WebUI**) Wait until WebUI is ready to open in browser
+- (**Downloads**) Truncate filenames by byte length to prevent "File name too long" IO errors
+- (**Downloads**) Fix being unable to find downloads after manga was renamed during an update
+- (**Downloads**) Fix preserving chapter download states during an update
+- (**Extension**) Do not indicate an update is available when the extension is not installed
+- (**Chapter**) Fix losing chapter data on failed chapter list update
+- (**Chapter**) Fix database error when fetching chapter updates
+- (**Manga/API**) Fix "mangas" graphql query with active sorting and using a PostgreSQL database (QUERY "mangas")
+- (**API**) Fix GraphQL `Filter` `notAll` and `notAny` being inversed
+- (**API**) Fix GraphQL `Filter` causing an UnsupportedOperationException when passing an empty list as a `Any` filter value
+- (**Build**) Fix CURL failing silently in builds
 
 ## [v2.2.2100] + [WebUI: v20260508.01] - 2026-05-08
 

README.md

@@ -8,7 +8,7 @@
   - [Features](#features)
 - [Suwayomi client projects](#suwayomi-client-projects)
   - [Integrated clients](#integrated-clients)
-  - [Other clients](#other-clients-potentially-inactive-or-abondend)
+  - [Other clients](#other-clients-potentially-inactive-or-abandoned)
 - [Downloading and Running the app](#downloading-and-running-the-app)
   - [Using Operating System Specific Bundles](#using-operating-system-specific-bundles)
     - [Windows](#windows)
@@ -82,6 +82,7 @@ These clients are built-in options, and the server can keep them automatically u
 - [Tachidesk-JUI](https://github.com/Suwayomi/Tachidesk-JUI): Desktop app (windows, linux, mac); can manage its own suwayomi server instance
 - [Tachidesk-Sorayomi](https://github.com/Suwayomi/Tachidesk-Sorayomi): Web app; Desktop app (windows, linux, mac); Android app; requires access to a running server
 - [Tachidesk-qtui](https://github.com/Suwayomi/Tachidesk-qtui): Android app; iOS app Desktop app (linux); requires access to a running server
+- [Suwayomi Client for KOReader](https://github.com/LK4D4/suwayomi.koplugin): KOReader plugin; works anywhere KOReader can run (Android, Kindle, Kobo, etc.); requires access to a running server
 
 # Downloading and Running the app
 ## Using Operating System Specific Bundles
@@ -106,23 +107,22 @@ Download the latest `linux-x64`(x86_64) release from [the releases section](http
 
 #### WebView support (GNU/Linux)
 
-WebView support is implemented via [KCEF](https://github.com/DATL4G/KCEF).
+WebView support is implemented via [JCEF](https://github.com/JetBrains/jcef).
 This is optional, and is only necessary to support some extensions.
 
-To have a functional WebView, several dependencies are required; aside from X11 libraries necessary for rendering Chromium, some JNI bindings are necessary: gluegen and jogl (found in Ubuntu as `libgluegen2-jni` and `libjogl2-jni`).
-Note that on some systems (e.g. Ubuntu), the JNI libraries are not automatically found, see below.
+To have a functional WebView, some X11 dependencies are required for rendering Chromium.
+These include `libxrender`, `libxcomposite` `libxdamage`, `libxkbcommon` and `libxtst`.
 
-A KCEF server is launched on startup, which loads the X11 libraries.
+A CEF server is launched on startup, which loads the X11 libraries.
 If those are missing, you should see "Could not load 'jcef' library".
 If so, use `ldd ~/.local/share/Tachidesk/bin/kcef/libjcef.so | grep not` to figure out which libraries are not found on your system.
 
-The JNI bindings are only loaded when a browser is actually launched.
-This is done by extensions that rely on WebView, not by Suwayomi itself.
-If there is a problem loading the JNI libraries, you should see a message indicating the library and the search path.
-This search path includes the current working directory, if you do not want to modify system directories.
-
 Refer to the [Dockerfile](https://github.com/Suwayomi/Suwayomi-Server-docker/blob/main/Dockerfile) for more details.
 
+Note that it is required to have an X session active and available to Suwayomi (i.e. `DISPLAY` is set).
+It is not enough to have `WAYLAND_DISPLAY`, if your environment does not provide xwayland (or if you run Suwayomi as a service), you need to use a tool like [`Xvfb`](https://en.wikipedia.org/wiki/Xvfb).
+The Dockerfile linked above also does this.
+
 ## Other methods of getting Suwayomi
 ### Docker
 Check our Official Docker release [Suwayomi Container](https://github.com/orgs/Suwayomi/packages/container/package/tachidesk) for running Suwayomi Server in a docker container. Source code for our container is available at [docker-tachidesk](https://github.com/Suwayomi/docker-tachidesk), an example compose file can also be found there. By default, the server will be running on http://localhost:4567 open this url in your browser.

build.gradle.kts

@@ -25,6 +25,7 @@ allprojects {
         maven("https://github.com/Suwayomi/Suwayomi-Server/raw/android-jar/")
         maven("https://jitpack.io")
         maven("https://jogamp.org/deployment/maven")
+        maven("https://packages.jetbrains.team/maven/p/ij/intellij-dependencies")
     }
 }
 

buildSrc/src/main/kotlin/Constants.kt

@@ -14,6 +14,8 @@ val getTachideskVersion = { "v2.2.${getCommitCount()}" }
 
 val webUIRevisionTag = "r3136"
 
+val webviewJbrRelease = "jbr-release-25.0.3b496.62"
+
 private val getCommitCount = {
     runCatching {
         ProcessBuilder()

docs/Configuring-Suwayomi‐Server.md

@@ -63,6 +63,14 @@ server.webUISubpath = ""
 - `server.webUIUpdateCheckInterval` the interval time in hours at which to check for updates. Use `0` to disable update checking.
 - `server.webUISubpath` controls on which sub-path the UI is served; by default, it will be accessible on `/` (i.e. directly), with this setting it can also be set to appear at e.g. `/suwayomi`
 
+
+### webView
+```
+server.kcefEnabled = true
+```
+- `server.kcefEnabled` controls if KCEF WebView provider is enabled.
+
+
 ### Downloader
 ```
 server.downloadAsCbz = true
@@ -268,6 +276,28 @@ server.useHikariConnectionPool = true
 - `server.databasePassword` the username with which to authenticate at the PostgreSQL instance.
 - `server.useHikariConnectionPool` use Hikari Connection Pool to connect to the database.
 
+### SyncYomi
+```
+server.syncYomiEnabled = false
+server.syncYomiHost = ""
+server.syncYomiApiKey = ""
+server.syncDataManga = true
+server.syncDataChapters = true
+server.syncDataTracking = true
+server.syncDataHistory = true
+server.syncDataCategories = true
+server.syncInterval = "0s"
+```
+- `server.syncYomiEnabled` controls whether SyncYomi is enabled.
+- `server.syncYomiHost` base URL of the SyncYomi server instance. e.g. `http://localhost:8282`
+- `server.syncYomiApiKey` API key to authenticate with SyncYomi. You must use the same API key in both Suwayomi and SyncYomi.
+- `server.syncDataManga` enables syncing manga.
+- `server.syncDataChapters` enables syncing chapters.
+- `server.syncDataTracking` enables syncing tracking data.
+- `server.syncDataHistory` enables syncing reading history.
+- `server.syncDataCategories` enables syncing categories.
+- `server.syncInterval` interval between automatic sync operations. Use `0s` to disable.
+
 **Note:** The example [docker-compose.yml file](https://github.com/Suwayomi/Suwayomi-Server-docker/blob/main/docker-compose.yml) contains everything you need to get started with Suwayomi+PostgreSQL. Please be aware that PostgreSQL support is currently still in beta.
 
 **Note:** These settings are excluded from backups, so a backup can be used to easily switch database installations by setting up the connection first, then restoring the backup.

docs/Troubleshooting.md

@@ -1,19 +1,92 @@
+# Troubleshooting
+
+This page is laid out in several sections, where each section describes a specific problem, followed by one or more possible solutions.
+
+At the end, you will find a General section, which is the nuclear option if nothing else works.
+
+For further support, visit the [official Suwayomi Discord server](https://discord.gg/DDZdqZWaHA).  
+In such cases, it will be helpful to have logs ready. You can find them in [The Data Directory](./The-Data-Directory) in the logs directory.
+
+**All steps below assume that you have stopped Suwayomi**.
+
+
+## Broken database
+
+- `failed due to
+org.jetbrains.exposed.exceptions.ExposedSQLException: org.h2.jdbc.JdbcSQLSyntaxErrorException: Column "CATEGORY.SORT_ORDER" not found`
+- `org.h2.jdbc.JdbcSQLSyntaxErrorException: Column "CHAPTER.KOREADER_HASH" not found`
+- `java.lang.IllegalStateException: Unable to read the page at position 96170708817765466`
+- Any other error text that includes "SQL Statement"
+
+Your database is either corrupted or incompatible.
+
+One of these is the cause:
+- You were running a preview version and decided to downgrade to stable.
+- You did not shut down Suwayomi properly.
+- Suwayomi crashed in an unexpected way.
+
+Solutions:
+- If you downgraded, upgrade to preview again.
+- Otherwise, you will need to reset and restore from a backup. See [General Troubleshooting](#general-troubleshooting) below.
+
+
+## `HTTP error 429`
+
+The source (or, if trackers are enabled, possibly the tracker) has blocked you for sending too many requests.  
+Note that Mass-Migration can result in an unexpectedly high number of requests to both the source and any configured trackers.
+
+Solution: Use other/more sources, download less, and wait between request-heavy actions.
+
+
+## Extension times out
+
+- `Timed out waiting for 20000 ms…`
+- `Timed out waiting for page list`
+
+First, check if this is an extension issue or a Suwayomi issue.
+On the manga page of the problematic entry, click "Open in WebView".
+
+Solutions:
+- If the WebView loads: The issue is with the extension. Search [the issues](https://github.com/Suwayomi/Suwayomi-Server/issues) and discord if there are known problems with that extension.
+- If the WebView errors: Go to [The Data Directory](./The-Data-Directory) and remove the `bin` and `cache` folders.
+    - If the WebView still does not work after a restart, your installation is incomplete. On Linux, refer to [the README](https://github.com/Suwayomi/Suwayomi-Server#webview-support-gnulinux).
+
+
+## Flaresolverr required
+
+- `java.io.IOException: Cloudflare bypass currently disabled`
+
+The source you are using has enabled CloudFlare's bot protection.
+If you open the source's website in your browser, you should see the "Confirm I'm human" page.
+
+Solution:
+- Download and set up [Flaresolverr](https://github.com/FlareSolverr/FlareSolverr) or [Byparr](https://github.com/ThePhaseless/Byparr). Make sure to run Flaresolverr/Byparr every time you use this source.
+
+
+## Flaresolverr not running
+
+- `java.io.IOException: Failed to connect to localhost/[0:0:0:0:0:0:0:1]:8191`
+
+You have configured Flaresolverr by enabling the `server.flareSolverrEnabled` setting, but Flaresolverr is not installed and/or running.
+
+Solutions:
+- Install Flaresolverr if you haven't already (see previous section). Then ensure it is running (Windows: do not close the console window!).
+- If it is running, ensure the configured url in `server.flareSolverrUrl` is correct. There is usually no need to change this.
+- If it is running and the url is correct, check your firewall settings, your system may be blocking access to Flaresolverr.
+
+
 ## General Troubleshooting
 This guide will try to fix Suwayomi by reseting it to a clean installation state.
 
+> [!WARNING]
+> This will remove all your data, including the library.
+> Make sure you have copied your backups as described above!
+
 - Make sure you have a recent backup of your library or create one in the app (if possible) because we **are going to wipe all Suwayomi data**.
 - Make sure Suwayomi is not running (right click on tray icon and quit or kill it through the way your Operating System provides)
 - Clear all browsing data on your browser if you use Suwayomi from a browser.
-- Delete the Suwayomi data directory located below and re-run the app.
-
-Note: Replace `<Account>` with the currently logged in account/username on your pc.
-
-On Mac OS X : `/Users/<Account>/Library/Application Support/Tachidesk`
-
-On Windows XP : `C:\Documents and Settings\<Account>\Application Data\Local Settings\Tachidesk`
-
-On Windows 7 and later : `C:\Users\<Account>\AppData\Local\Tachidesk`
-
-On Unix/Linux : `/home/<account>/.local/share/Tachidesk`
-
+- Delete the Suwayomi data directory located below and re-run the app. See the article [The Data Directory](./The-Data-Directory) for information on how to find it.
+    - If you wish to keep your downloads, you may also attempt to surgically remove only parts. You will need to remove `database.mv.db`, `database.trace.db`, `bin`, `cache`, `extensions`, `settings`, `webUI`. Removing only a subset of these files and folders may fail to resolve the problem.
+- Open Suwayomi and go to Settings > Backup > Restore Backup, and select the latest backup you have.
+    - Restoring from backup does not restore your downloads. If you chose to keep them in the above step, you will now need to re-download all manga. Suwayomi will pick up on the existing files and not actually download anything that isn't new.
 - In the case that you have to periodically perform this fix or the problem persists or the method failed to fix it, open an issue or Join the [Suwayomi discord server](https://discord.gg/DDZdqZWaHA) to hang out with the community and to receive support and help.

gradle/libs.versions.toml

@@ -1,22 +1,23 @@
 [versions]
-kotlin = "2.3.21"
+kotlin = "2.4.0"
 coroutines = "1.11.0"
 serialization = "1.11.0"
 jvmTarget = "21"
 okhttp = "5.3.2" # Major version is locked by Tachiyomi extensions
-javalin = "7.2.0"
+javalin = "7.2.2"
 jte = "3.2.4"
-jackson = "3.1.3" # jackson version locked by javalin, ref: `io.javalin.core.util.OptionalDependency`
+jackson = "3.1.4" # jackson version locked by javalin, ref: `io.javalin.core.util.OptionalDependency`
 exposed = "1.2.0"
 dex2jar = "2.4.36"
 polyglot = "25.0.3"
 settings = "1.3.0"
 twelvemonkeys = "3.13.1"
-graphqlkotlin = "10.0.0-alpha.3"
+graphqlkotlin = "10.0.0"
 xmlserialization = "0.91.3"
 ktlint = "1.8.0"
 koin = "4.2.1"
 moko = "0.26.4"
+jcef = "144.0.15-g72717cf-chromium-144.0.7559.172-api-1.21-262-b37"
 
 [libraries]
 # Kotlin
@@ -37,9 +38,9 @@ serialization-xml-core = { module = "io.github.pdvrieze.xmlutil:core", version.r
 serialization-xml = { module = "io.github.pdvrieze.xmlutil:serialization-jvm", version.ref = "xmlserialization" }
 
 # Logging
-slf4japi = "org.slf4j:slf4j-api:2.0.17"
-logback = "ch.qos.logback:logback-classic:1.5.32"
-kotlinlogging = "io.github.oshai:kotlin-logging-jvm:8.0.02"
+slf4japi = "org.slf4j:slf4j-api:2.0.18"
+logback = "ch.qos.logback:logback-classic:1.5.34"
+kotlinlogging = "io.github.oshai:kotlin-logging-jvm:8.0.4"
 
 # OkHttp
 okhttp-core = { module = "com.squareup.okhttp3:okhttp", version.ref = "okhttp" }
@@ -54,7 +55,7 @@ javalin-openapi = { module = "io.javalin:javalin-openapi", version.ref = "javali
 javalin-rendering = { module = "io.javalin:javalin-rendering-jte", version.ref = "javalin" }
 jackson-databind = { module = "tools.jackson.core:jackson-databind", version.ref = "jackson" }
 jackson-kotlin = { module = "tools.jackson.module:jackson-module-kotlin", version.ref = "jackson" }
-jackson-annotations = "com.fasterxml.jackson.core:jackson-annotations:2.21"
+jackson-annotations = "com.fasterxml.jackson.core:jackson-annotations:2.22"
 jte = { module = "gg.jte:jte", version.ref = "jte" }
 kte = { module = "gg.jte:jte-kotlin", version.ref = "jte" }
 
@@ -90,7 +91,7 @@ rxjava = "io.reactivex:rxjava:1.3.8"
 jsoup = "org.jsoup:jsoup:1.22.2"
 
 # Config
-config = "com.typesafe:config:1.4.8"
+config = "com.typesafe:config:1.4.9"
 config4k = "io.github.config4k:config4k:0.7.0"
 
 # Sort
@@ -116,7 +117,7 @@ appdirs = "ca.gosyer:kotlin-multiplatform-appdirs:2.0.0"
 cache4k = "io.github.reactivecircus.cache4k:cache4k:0.14.0"
 zip4j = "net.lingala.zip4j:zip4j:2.11.6"
 commonscompress = "org.apache.commons:commons-compress:1.28.0"
-junrar = "com.github.junrar:junrar:7.5.10"
+junrar = "com.github.junrar:junrar:7.6.0"
 
 # AES/CBC/PKCS7Padding Cypher provider
 bouncycastle = "org.bouncycastle:bcprov-jdk18on:1.84"
@@ -147,7 +148,7 @@ twelvemonkeys-imageio-webp = { module = "com.twelvemonkeys.imageio:imageio-webp"
 imageio-webp = "com.github.usefulness:webp-imageio:0.10.2"
 
 # Testing
-mockk = "io.mockk:mockk:1.14.9"
+mockk = "io.mockk:mockk:1.14.11"
 
 # cron scheduler
 cron4j = "it.sauronsoftware.cron4j:cron4j:2.2.5"
@@ -156,7 +157,7 @@ cron4j = "it.sauronsoftware.cron4j:cron4j:2.2.5"
 cronUtils = "com.cronutils:cron-utils:9.2.1"
 
 # Webview
-kcef = "dev.datlag:kcef:2024.04.20.4"
+jcef = { module = "org.jetbrains.intellij.deps.jcef:jcef", version.ref = "jcef" }
 
 # User
 jwt = "com.auth0:java-jwt:4.5.2"
@@ -177,13 +178,13 @@ kotlin-multiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref
 ktlint = { id = "org.jlleitschuh.gradle.ktlint", version = "14.2.0"}
 
 # Build config
-buildconfig = { id = "com.github.gmazzo.buildconfig", version = "6.0.9"}
+buildconfig = { id = "com.github.gmazzo.buildconfig", version = "6.0.10"}
 
 # Download
 download = { id = "de.undercouch.download", version = "5.7.0"}
 
 # ShadowJar
-shadowjar = { id = "com.gradleup.shadow", version = "8.3.10"}
+shadowjar = { id = "com.gradleup.shadow", version = "8.3.11"}
 
 # Moko
 moko = { id = "dev.icerock.mobile.multiplatform-resources", version.ref = "moko" }
@@ -213,7 +214,7 @@ shared = [
     "dex2jar-tools",
     "apk-parser",
     "jackson-annotations",
-    "kcef"
+    "jcef",
 ]
 
 sharedTest = [

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-9.5.0-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.5.1-bin.zip
 networkTimeout=10000
 retries=0
 retryBackOffMs=500

renovate.json

@@ -16,14 +16,43 @@
       "depNameTemplate": "zulu",
       "datasourceTemplate": "custom.zulu",
       "versioningTemplate": "regex:^(?<major>\\d+)\\.(?<minor>\\d+)\\.(?<patch>\\d+).*$"
+    },
+    {
+      "customType": "regex",
+      "managerFilePatterns": [
+        "/buildSrc/src/main/kotlin/Constants.kt/"
+      ],
+      "matchStrings": [
+        "val\\s+webviewJbrRelease\\s*=\\s*\"(?<currentValue>[^\"]+)\""
+      ],
+      "depNameTemplate": "JetBrainsRuntime",
+      "packageNameTemplate": "JetBrains/JetBrainsRuntime",
+      "datasourceTemplate": "github-releases",
+      "versioningTemplate": "regex:^jbr-release-(?<major>\\d+)\\.(?<minor>\\d+)\\.(?<patch>\\d+)b(?<build>\\d+)\\.(?<revision>\\d+)$"
     }
   ],
   "customDatasources": {
     "zulu": {
       "defaultRegistryUrlTemplate": "https://api.azul.com/metadata/v1/zulu/packages?availability_types=ca&release_status=both&java_package_type=jre&crac_supported=false&javafx_bundled=false&support_term=lts&arch=x86&os=linux&archive_type=zip&page_size=1000&include_fields=java_package_features,release_status,support_term,os,arch,hw_bitness,abi,java_package_type,javafx_bundled,sha256_hash,cpu_gen,size,archive_type,certifications,lib_c_type,crac_supported&page=1&azul_com=true",
       "transformTemplates": [
-        "{\"releases\": $$.$join([$join($map(distro_version[[0..2]], $string), \".\"), \"_\", $join($map(java_version, $string), \".\")])}"
+        "{ \"releases\": $map($, function($v) { { \"version\": $join([$string($v.distro_version[0]), \".\", $string($v.distro_version[1]), \".\", $string($v.distro_version[2]), \"_\", $string($v.java_version[0]), \".\", $string($v.java_version[1]), \".\", $string($v.java_version[2])]) } }) }"
       ]
     }
-  }
+  },
+  "packageRules": [
+    {
+      "matchPackageNames": [
+        "org.jetbrains.intellij.deps.jcef:jcef",
+        "JetBrains/JetBrainsRuntime"
+      ],
+      "groupName": "JCEF + JetBrains Runtime",
+      "groupSlug": "jcef-jbr"
+    },
+    {
+      "matchPackageNames": [
+        "com.github.Suwayomi:android-jar"
+      ],
+      "enabled": false
+    }
+  ]
 }

scripts/bundler.sh

@@ -42,7 +42,7 @@ main() {
     gcc -fPIC -shared scripts/resources/catch_abort.c -lpthread -o scripts/resources/catch_abort.so
   fi
 
-  JRE_ZULU="25.30.17_25.0.1"
+  JRE_ZULU="25.34.17_25.0.3"
   JRE_RELEASE="jre${JRE_ZULU#*_}" # e.g. jre25.0.1
   ZULU_RELEASE="zulu${JRE_ZULU%_*}" # e.g. zulu25.30.17
 
@@ -149,15 +149,15 @@ move_release_to_output_dir() {
 }
 
 download_launcher() {
-  LAUNCHER_URL=$(curl -s "https://api.github.com/repos/Suwayomi/Suwayomi-Launcher/releases/latest" | grep "browser_download_url" | grep ".jar" | head -n 1 | cut -d '"' -f 4)
-  curl -L "$LAUNCHER_URL" -o "Suwayomi-Launcher.jar"
+  LAUNCHER_URL=$(curl -sf "https://api.github.com/repos/Suwayomi/Suwayomi-Launcher/releases/latest" | grep "browser_download_url" | grep ".jar" | head -n 1 | cut -d '"' -f 4)
+  curl -fL "$LAUNCHER_URL" -o "Suwayomi-Launcher.jar"
   mv "Suwayomi-Launcher.jar" "$RELEASE_NAME/Suwayomi-Launcher.jar"
 }
 
 download_jogamp() {
   local platform="$1"
   if [ ! -f jogamp-all-platforms.7z ]; then
-    curl "https://jogamp.org/deployment/jogamp-current/archive/jogamp-all-platforms.7z" -o jogamp-all-platforms.7z
+    curl -f "https://jogamp.org/deployment/jogamp-current/archive/jogamp-all-platforms.7z" -o jogamp-all-platforms.7z
   fi
 
   7z x jogamp-all-platforms.7z "jogamp-all-platforms/lib/$platform/"
@@ -168,7 +168,7 @@ download_jogamp() {
 
 download_electron() {
   if [ ! -f "$ELECTRON" ]; then
-    curl -L "$ELECTRON_URL" -o "$ELECTRON"
+    curl -fL "$ELECTRON_URL" -o "$ELECTRON"
   fi
 
   unzip "$ELECTRON" -d "$RELEASE_NAME/electron/"
@@ -181,7 +181,7 @@ setup_jre() {
     mv "jre" "$RELEASE_NAME/jre"
   else
     if [ ! -f "$JRE" ]; then
-      curl -L "$JRE_URL" -o "$JRE"
+      curl -fL "$JRE_URL" -o "$JRE"
     fi
 
     local ext="${JRE##*.}"
@@ -273,7 +273,7 @@ make_appimage() {
     sudo apt update
     sudo apt install libfuse2
   fi
-  curl -L $APPIMAGE_URL -o $APPIMAGE_TOOLNAME
+  curl -fL $APPIMAGE_URL -o $APPIMAGE_TOOLNAME
   chmod +x $APPIMAGE_TOOLNAME
   ARCH=x86_64 ./$APPIMAGE_TOOLNAME "$RELEASE_NAME" "$RELEASE"
 }
@@ -300,7 +300,7 @@ make_windows_bundle() {
   #local rcedit_url="https://github.com/electron/rcedit/releases/download/v0.1.1/$rcedit"
   ## change electron's icon
   #if [ ! -f "$rcedit" ]; then
-    #curl -L "$rcedit_url" -o "$rcedit"
+    #curl -fL "$rcedit_url" -o "$rcedit"
   #fi
 
   #local icon="server/src/main/resources/icon/faviconlogo.ico"

server/build.gradle.kts

@@ -159,6 +159,8 @@ buildConfig {
 
     buildConfigField("String", "GITHUB", quoteWrap("https://github.com/Suwayomi/Suwayomi-Server"))
     buildConfigField("String", "DISCORD", quoteWrap("https://discord.gg/DDZdqZWaHA"))
+    buildConfigField("String", "JCEF_VERSION", quoteWrap(libs.versions.jcef.get()))
+    buildConfigField("String", "JCEF_JBR_RELEASE", quoteWrap(webviewJbrRelease))
 }
 
 tasks {
@@ -172,6 +174,7 @@ tasks {
                 "Specification-Version" to getTachideskVersion(),
                 "Implementation-Version" to getTachideskRevision(),
                 "Multi-Release" to true, // needed for polyglot
+                "X-JBR-Release" to webviewJbrRelease,
             )
         }
         archiveBaseName.set(rootProject.name)
@@ -182,7 +185,11 @@ tasks {
     }
 
     test {
-        useJUnitPlatform()
+        useJUnitPlatform {
+            if (!project.hasProperty("masstest")) {
+                exclude("**/masstest/*")
+            }
+        }
         testLogging {
             showStandardStreams = true
             events("passed", "skipped", "failed")

server/server-config/src/main/kotlin/suwayomi/tachidesk/server/ServerConfig.kt

@@ -20,6 +20,7 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.conflate
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.drop
 import kotlinx.coroutines.flow.launchIn
@@ -73,6 +74,21 @@ val serverConfig: ServerConfig by lazy { GlobalConfigManager.module() }
 
 private val application: Application by injectLazy()
 
+@OptIn(ExperimentalCoroutinesApi::class)
+fun <T> subscribeTo(
+    flow: Flow<T>,
+    ignoreInitialValue: Boolean = true,
+    onChange: suspend (value: T) -> Unit,
+) {
+    val actualFlow =
+        if (ignoreInitialValue) {
+            flow.drop(1)
+        } else {
+            flow
+        }
+    actualFlow.distinctUntilChanged().conflate().onEach { onChange(it) }.launchIn(mutableConfigValueScope)
+}
+
 // Settings are ordered by "protoNumber".
 class ServerConfig(
     getConfig: () -> Config,
@@ -1014,7 +1030,76 @@ class ServerConfig(
         description = "Use Hikari Connection Pool to connect to the database.",
     )
 
+    val kcefEnabled: MutableStateFlow<Boolean> by BooleanSetting(
+        protoNumber = 86,
+        group = SettingGroup.WEB_VIEW,
+        privacySafe = true,
+        defaultValue = true,
+        description = "Enable the WebView via CEF (Chromium)"
+    )
 
+    val syncYomiEnabled: MutableStateFlow<Boolean> by BooleanSetting(
+        protoNumber = 87,
+        defaultValue = false,
+        group = SettingGroup.SYNCYOMI,
+        privacySafe = true
+    )
+
+    val syncYomiHost: MutableStateFlow<String> by StringSetting(
+        protoNumber = 88,
+        defaultValue = "",
+        group = SettingGroup.SYNCYOMI,
+        privacySafe = true,
+    )
+
+    val syncYomiApiKey: MutableStateFlow<String> by StringSetting(
+        protoNumber = 89,
+        defaultValue = "",
+        group = SettingGroup.SYNCYOMI,
+        privacySafe = false,
+    )
+
+    val syncDataManga: MutableStateFlow<Boolean> by BooleanSetting(
+        protoNumber = 90,
+        defaultValue = true,
+        group = SettingGroup.SYNCYOMI,
+        privacySafe = true,
+    )
+
+    val syncDataChapters: MutableStateFlow<Boolean> by BooleanSetting(
+        protoNumber = 91,
+        defaultValue = true,
+        group = SettingGroup.SYNCYOMI,
+        privacySafe = true,
+    )
+
+    val syncDataTracking: MutableStateFlow<Boolean> by BooleanSetting(
+        protoNumber = 92,
+        defaultValue = true,
+        group = SettingGroup.SYNCYOMI,
+        privacySafe = true,
+    )
+
+    val syncDataHistory: MutableStateFlow<Boolean> by BooleanSetting(
+        protoNumber = 93,
+        defaultValue = true,
+        group = SettingGroup.SYNCYOMI,
+        privacySafe = true,
+    )
+
+    val syncDataCategories: MutableStateFlow<Boolean> by BooleanSetting(
+        protoNumber = 94,
+        defaultValue = true,
+        group = SettingGroup.SYNCYOMI,
+        privacySafe = true,
+    )
+
+    val syncInterval: MutableStateFlow<Duration> by DurationSetting(
+        protoNumber = 95,
+        defaultValue = 0.seconds,
+        group = SettingGroup.SYNCYOMI,
+        privacySafe = true,
+    )
 
     /** ****************************************************************** **/
     /**                                                                    **/
@@ -1059,18 +1144,7 @@ class ServerConfig(
         flow: Flow<T>,
         onChange: suspend (value: T) -> Unit,
         ignoreInitialValue: Boolean = true,
-    ) {
-        val actualFlow =
-            if (ignoreInitialValue) {
-                flow.drop(1)
-            } else {
-                flow
-            }
-
-        val sharedFlow = MutableSharedFlow<T>(extraBufferCapacity = 1, onBufferOverflow = BufferOverflow.DROP_OLDEST)
-        actualFlow.distinctUntilChanged().mapLatest { sharedFlow.emit(it) }.launchIn(mutableConfigValueScope)
-        sharedFlow.onEach { onChange(it) }.launchIn(mutableConfigValueScope)
-    }
+    ) = subscribeTo(flow, ignoreInitialValue, onChange)
 
     fun <T> subscribeTo(
         flow: Flow<T>,

server/server-config/src/main/kotlin/suwayomi/tachidesk/server/settings/SettingGroup.kt

@@ -17,6 +17,8 @@ enum class SettingGroup(
     CLOUDFLARE("Cloudflare"),
     OPDS("OPDS"),
     KOREADER_SYNC("KOReader sync"),
+    WEB_VIEW("WebView"),
+    SYNCYOMI("SyncYomi")
     ;
 
     override fun toString(): String = value

server/server-config/src/main/kotlin/suwayomi/tachidesk/server/settings/SettingsRegistry.kt

@@ -88,4 +88,6 @@ object SettingsRegistry {
     fun get(name: String): SettingMetadata? = settings[name]
 
     fun getAll(): Map<String, SettingMetadata> = settings.toMap()
+
+    fun clear() = settings.clear()
 }

server/src/main/kotlin/suwayomi/tachidesk/global/impl/KcefWebView.kt

@@ -1,15 +1,14 @@
 package suwayomi.tachidesk.global.impl
 
-import dev.datlag.kcef.KCEF
-import dev.datlag.kcef.KCEFBrowser
-import dev.datlag.kcef.KCEFClient
 import eu.kanade.tachiyomi.network.NetworkHelper
 import io.github.oshai.kotlinlogging.KotlinLogging
+import kotlinx.coroutines.runBlocking
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.json.Json
 import okhttp3.Cookie
 import okhttp3.HttpUrl
+import org.cef.CefClient
 import org.cef.CefSettings
 import org.cef.browser.CefBrowser
 import org.cef.browser.CefFrame
@@ -26,6 +25,9 @@ import org.cef.network.CefCookie
 import org.cef.network.CefCookieManager
 import org.cef.network.CefRequest
 import uy.kohesive.injekt.injectLazy
+import xyz.nulldev.androidcompat.webkit.CefHelper
+import xyz.nulldev.androidcompat.webkit.dispose
+import xyz.nulldev.androidcompat.webkit.evaluateJavaScript
 import java.awt.Component
 import java.awt.HeadlessException
 import java.awt.Rectangle
@@ -47,8 +49,8 @@ import javax.swing.JPanel
 class KcefWebView {
     private val logger = KotlinLogging.logger {}
     private val renderHandler = RenderHandler()
-    private var kcefClient: KCEFClient? = null
-    private var browser: KCEFBrowser? = null
+    private var kcefClient: CefClient? = null
+    private var browser: CefBrowser? = null
     private var width = 1000
     private var height = 1000
 
@@ -76,7 +78,8 @@ class KcefWebView {
         }
     }
 
-    @Serializable sealed class Event
+    @Serializable
+    sealed class Event
 
     @Serializable
     @SerialName("consoleMessage")
@@ -247,10 +250,12 @@ class KcefWebView {
     init {
         destroy()
         kcefClient =
-            KCEF.newClientBlocking().apply {
-                addDisplayHandler(DisplayHandler())
-                addLoadHandler(LoadHandler())
-                addRequestHandler(RequestHandler())
+            runBlocking {
+                CefHelper.createClient().apply {
+                    addDisplayHandler(DisplayHandler())
+                    addLoadHandler(LoadHandler())
+                    addRequestHandler(RequestHandler())
+                }
             }
 
         logger.debug { "Start loading cookies" }
@@ -289,6 +294,7 @@ class KcefWebView {
                 .createBrowser(
                     url,
                     CefRendering.CefRenderingWithHandler(renderHandler, JPanel()),
+                    false,
                     // NOTE: with a context, we don't seem to be getting any cookies
                 ).apply {
                     // NOTE: Without this, we don't seem to be receiving any events

server/src/main/kotlin/suwayomi/tachidesk/global/impl/sync/SyncManager.kt

@@ -0,0 +1,519 @@
+package suwayomi.tachidesk.global.impl.sync
+
+import android.app.Application
+import android.content.Context
+import io.github.oshai.kotlinlogging.KotlinLogging
+import kotlinx.coroutines.DelicateCoroutinesApi
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.protobuf.ProtoBuf
+import org.jetbrains.exposed.v1.core.and
+import org.jetbrains.exposed.v1.core.eq
+import org.jetbrains.exposed.v1.jdbc.selectAll
+import org.jetbrains.exposed.v1.jdbc.transactions.transaction
+import org.jetbrains.exposed.v1.jdbc.update
+import suwayomi.tachidesk.graphql.types.StartSyncResult
+import suwayomi.tachidesk.manga.impl.Category
+import suwayomi.tachidesk.manga.impl.Library.handleMangaThumbnail
+import suwayomi.tachidesk.manga.impl.backup.BackupFlags
+import suwayomi.tachidesk.manga.impl.backup.proto.ProtoBackupImport
+import suwayomi.tachidesk.manga.impl.backup.proto.handlers.BackupCategoryHandler
+import suwayomi.tachidesk.manga.impl.backup.proto.handlers.BackupMangaHandler
+import suwayomi.tachidesk.manga.impl.backup.proto.handlers.BackupSourceHandler
+import suwayomi.tachidesk.manga.impl.backup.proto.models.Backup
+import suwayomi.tachidesk.manga.impl.backup.proto.models.BackupChapter
+import suwayomi.tachidesk.manga.impl.backup.proto.models.BackupManga
+import suwayomi.tachidesk.manga.model.dataclass.ChapterDataClass
+import suwayomi.tachidesk.manga.model.dataclass.MangaDataClass
+import suwayomi.tachidesk.manga.model.table.CategoryMangaTable
+import suwayomi.tachidesk.manga.model.table.CategoryTable
+import suwayomi.tachidesk.manga.model.table.ChapterTable
+import suwayomi.tachidesk.manga.model.table.MangaTable
+import suwayomi.tachidesk.manga.model.table.toDataClass
+import suwayomi.tachidesk.server.serverConfig
+import suwayomi.tachidesk.util.HAScheduler
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import kotlin.time.Clock
+import kotlin.time.Duration.Companion.seconds
+import kotlin.time.Instant
+import kotlin.time.measureTime
+
+@Serializable
+data class SyncData(
+    val backup: Backup? = null,
+)
+
+object SyncManager {
+    private val syncPreferences = Injekt.get<Application>().getSharedPreferences("sync", Context.MODE_PRIVATE)
+    private val logger = KotlinLogging.logger {}
+
+    private var currentTaskId: String? = null
+    private val syncMutex = Mutex()
+
+    private val _lastSyncState: MutableStateFlow<SyncState?> = MutableStateFlow(null)
+    val lastSyncState: StateFlow<SyncState?> = _lastSyncState.asStateFlow()
+
+    @OptIn(DelicateCoroutinesApi::class)
+    fun scheduleSyncTask() {
+        serverConfig.subscribeTo(
+            combine(
+                serverConfig.syncYomiEnabled,
+                serverConfig.syncInterval,
+            ) { enabled, interval -> Pair(enabled, interval) },
+            { (enabled, interval) ->
+                currentTaskId?.let { HAScheduler.deschedule(it) }
+
+                currentTaskId =
+                    if (enabled && interval > 0.seconds) {
+                        val lastSyncDate =
+                            syncPreferences
+                                .getLong("last_scheduled_sync", 0L)
+                                .takeIf { it != 0L }
+                                ?.let { Instant.fromEpochMilliseconds(it) }
+
+                        if (lastSyncDate == null) {
+                            syncPreferences
+                                .edit()
+                                .putLong("last_scheduled_sync", Clock.System.now().toEpochMilliseconds())
+                                .apply()
+                        }
+
+                        val delay =
+                            if (lastSyncDate != null) {
+                                ((interval) - (Clock.System.now() - lastSyncDate)).coerceAtLeast(0.seconds)
+                            } else {
+                                interval
+                            }
+
+                        HAScheduler.schedule(
+                            {
+                                startSync(periodic = true)
+
+                                syncPreferences
+                                    .edit()
+                                    .putLong("last_scheduled_sync", Clock.System.now().toEpochMilliseconds())
+                                    .apply()
+                            },
+                            interval = interval.inWholeMilliseconds,
+                            delay = delay.inWholeMilliseconds,
+                            name = "sync",
+                        )
+                    } else {
+                        syncPreferences
+                            .edit()
+                            .remove("last_scheduled_sync")
+                            .apply()
+                        null
+                    }
+            },
+            ignoreInitialValue = false,
+        )
+    }
+
+    @OptIn(DelicateCoroutinesApi::class)
+    fun startSync(periodic: Boolean = false): StartSyncResult {
+        if (!serverConfig.syncYomiEnabled.value) {
+            return StartSyncResult.SYNC_DISABLED
+        }
+
+        if (!syncMutex.tryLock()) {
+            return StartSyncResult.SYNC_IN_PROGRESS
+        }
+
+        GlobalScope.launch {
+            try {
+                syncData(periodic)
+            } finally {
+                syncMutex.unlock()
+            }
+        }
+
+        return StartSyncResult.SUCCESS
+    }
+
+    suspend fun ensureSync() {
+        if (!serverConfig.syncYomiEnabled.value) {
+            return
+        }
+
+        if (syncMutex.tryLock()) {
+            // there is no ongoing sync, so start one
+            try {
+                syncData()
+            } finally {
+                syncMutex.unlock()
+            }
+        } else {
+            // wait for the ongoing sync to finish
+            syncMutex.withLock {}
+        }
+    }
+
+    private suspend fun syncData(periodic: Boolean = false) {
+        val startInstant = Clock.System.now()
+        _lastSyncState.value = SyncState.Started(startInstant)
+
+        try {
+            logger.info {
+                if (periodic) {
+                    "Starting periodic sync"
+                } else {
+                    "Starting manual sync"
+                }
+            }
+
+            transaction {
+                MangaTable.update({ MangaTable.isSyncing eq true }) {
+                    it[isSyncing] = false
+                }
+                ChapterTable.update({ ChapterTable.isSyncing eq true }) {
+                    it[isSyncing] = false
+                }
+                CategoryTable.update({ CategoryTable.isSyncing eq true }) {
+                    it[isSyncing] = false
+                }
+            }
+
+            val backupFlags =
+                BackupFlags(
+                    includeManga = serverConfig.syncDataManga.value,
+                    includeCategories = serverConfig.syncDataCategories.value,
+                    includeChapters = serverConfig.syncDataChapters.value,
+                    includeTracking = serverConfig.syncDataTracking.value,
+                    includeHistory = serverConfig.syncDataHistory.value,
+                    includeClientData = false,
+                    includeServerSettings = false,
+                )
+
+            _lastSyncState.value = SyncState.CreatingBackup(startInstant)
+            val backupMangas = BackupMangaHandler.backup(backupFlags)
+            val backup =
+                Backup(
+                    backupMangas,
+                    BackupCategoryHandler.backup(backupFlags).filter { it.name != Category.DEFAULT_CATEGORY_NAME },
+                    BackupSourceHandler.backup(backupMangas, backupFlags),
+                    emptyMap(),
+                    null,
+                )
+
+            val syncData =
+                SyncData(
+                    backup = backup,
+                )
+
+            val remoteBackup =
+                SyncYomiSyncService.doSync(syncData, startInstant) {
+                    _lastSyncState.value = it
+                }
+
+            if (remoteBackup == null) {
+                logger.debug { "Skip restore due to network issues" }
+                finishWithError(startInstant, "Network error", periodic)
+                return
+            }
+
+            if (remoteBackup === syncData.backup) {
+                // nothing changed
+                logger.debug { "Skip restore due to remote was overwrite from local" }
+                finishWithSuccess(startInstant, periodic)
+                return
+            }
+
+            // Stop the sync early if the remote backup is null or empty
+            if (remoteBackup.backupManga.isEmpty() && remoteBackup.backupCategories.isEmpty() && remoteBackup.backupSources.isEmpty()) {
+                logger.error { "No data found on remote server." }
+                finishWithError(startInstant, "No data found on remote server.", periodic)
+                return
+            }
+
+            val isLibraryEmpty =
+                transaction {
+                    MangaTable
+                        .selectAll()
+                        .where { MangaTable.inLibrary eq true }
+                        .empty()
+                }
+
+            // Check if it's first sync based on lastSyncTimestamp
+            if (syncPreferences.getLong("last_sync_timestamp", 0) == 0L && !isLibraryEmpty) {
+                // It's first sync no need to restore data. (just update remote data)
+                finishWithSuccess(startInstant, periodic)
+                return
+            }
+
+            val (filteredFavorites, nonFavorites) = filterFavoritesAndNonFavorites(remoteBackup)
+            updateNonFavorites(nonFavorites)
+
+            val newSyncData =
+                backup.copy(
+                    backupManga = filteredFavorites,
+                    backupCategories = remoteBackup.backupCategories,
+                    backupSources = remoteBackup.backupSources,
+                )
+
+            val hasMangaChanges = filteredFavorites.isNotEmpty()
+            val hasCategoryChanges = remoteBackup.backupCategories != backup.backupCategories
+            val hasSourceChanges = remoteBackup.backupSources != backup.backupSources
+
+            if (!hasMangaChanges && !hasCategoryChanges && !hasSourceChanges) {
+                // update the sync timestamp
+                finishWithSuccess(startInstant, periodic)
+                return
+            }
+
+            if (serverConfig.syncDataCategories.value) {
+                val mergedUids = newSyncData.backupCategories.map { it.uid }.toSet()
+                val mergedNames = newSyncData.backupCategories.map { it.name }.toSet()
+                val localCategories = Category.getCategoryList().filterNot { it.default } // Exclude system category
+                val categoriesToDelete =
+                    localCategories.filter {
+                        it.uid !in mergedUids && it.name !in mergedNames
+                    }
+                if (categoriesToDelete.isNotEmpty()) {
+                    transaction {
+                        categoriesToDelete.forEach {
+                            Category.removeCategory(it.id)
+                        }
+                    }
+                }
+            }
+
+            val backupStream = ProtoBuf.encodeToByteArray(Backup.serializer(), newSyncData).inputStream()
+            val restoreId =
+                ProtoBackupImport.restore(
+                    sourceStream = backupStream,
+                    flags = backupFlags,
+                    isSync = true,
+                )
+            _lastSyncState.value = SyncState.Restoring(startInstant, restoreId)
+
+            ProtoBackupImport.notifyFlow.first {
+                val restoreState = ProtoBackupImport.getRestoreState(restoreId)
+
+                restoreState == ProtoBackupImport.BackupRestoreState.Success ||
+                    restoreState == ProtoBackupImport.BackupRestoreState.Failure
+            }
+
+            // update the sync timestamp
+            finishWithSuccess(startInstant, periodic)
+        } catch (e: Throwable) {
+            logger.error { "Error syncing: ${e.message}" }
+            finishWithError(startInstant, "${e::class.qualifiedName}: ${e.message}", periodic)
+        }
+    }
+
+    private fun finishWithSuccess(
+        startInstant: Instant,
+        periodic: Boolean,
+    ) {
+        syncPreferences
+            .edit()
+            .putLong("last_sync_timestamp", Clock.System.now().toEpochMilliseconds())
+            .apply()
+        _lastSyncState.value = SyncState.Success(startInstant)
+
+        logger.info {
+            if (periodic) {
+                "Periodic sync completed successfully"
+            } else {
+                "Manual sync completed successfully"
+            }
+        }
+    }
+
+    private fun finishWithError(
+        startInstant: Instant,
+        message: String,
+        periodic: Boolean,
+    ) {
+        _lastSyncState.value = SyncState.Error(startInstant, message)
+
+        logger.info {
+            if (periodic) {
+                "Periodic sync failed: $message"
+            } else {
+                "Manual sync failed: $message"
+            }
+        }
+    }
+
+    private fun isMangaDifferent(
+        localManga: MangaDataClass,
+        remoteManga: BackupManga,
+    ): Boolean {
+        if (localManga.version != remoteManga.version) {
+            return true
+        }
+
+        val localChapters =
+            transaction {
+                ChapterTable
+                    .selectAll()
+                    .where { ChapterTable.manga eq localManga.id }
+                    .map { ChapterTable.toDataClass(it) }
+            }
+
+        if (areChaptersDifferent(localChapters, remoteManga.chapters)) {
+            return true
+        }
+
+        val localCategories =
+            transaction {
+                CategoryMangaTable
+                    .innerJoin(CategoryTable)
+                    .selectAll()
+                    .where { CategoryMangaTable.manga eq localManga.id }
+                    .map { it[CategoryTable.order] }
+            }
+
+        return localCategories.toSet() != remoteManga.categories.toSet()
+    }
+
+    private fun areChaptersDifferent(
+        localChapters: List<ChapterDataClass>,
+        remoteChapters: List<BackupChapter>,
+    ): Boolean {
+        val localChapterMap = localChapters.associateBy { it.url }
+        val remoteChapterMap = remoteChapters.associateBy { it.url }
+
+        if (localChapterMap.size != remoteChapterMap.size) {
+            return true
+        }
+
+        for ((url, localChapter) in localChapterMap) {
+            val remoteChapter = remoteChapterMap[url]
+
+            // If a matching remote chapter doesn't exist, or the version numbers are different, consider them different
+            if (remoteChapter == null || localChapter.version != remoteChapter.version) {
+                return true
+            }
+        }
+
+        return false
+    }
+
+    private fun filterFavoritesAndNonFavorites(backup: Backup): Pair<List<BackupManga>, List<BackupManga>> {
+        val favorites = mutableListOf<BackupManga>()
+        val nonFavorites = mutableListOf<BackupManga>()
+
+        val elapsedTime =
+            measureTime {
+                logger.debug { "Starting to filter favorites and non-favorites from backup data." }
+
+                backup.backupManga.forEach { remoteManga ->
+                    val localManga =
+                        transaction {
+                            MangaTable
+                                .selectAll()
+                                .where {
+                                    (MangaTable.sourceReference eq remoteManga.source) and
+                                        (MangaTable.url eq remoteManga.url)
+                                }.limit(1)
+                                .map { MangaTable.toDataClass(it) }
+                                .firstOrNull()
+                        }
+
+                    when {
+                        // Checks if the manga is in favorites and needs updating or adding
+                        remoteManga.favorite -> {
+                            if (localManga == null || isMangaDifferent(localManga, remoteManga)) {
+                                logger.debug { "Adding to favorites: ${remoteManga.title}" }
+                                favorites.add(remoteManga)
+                            } else {
+                                logger.debug { "Already up-to-date favorite: ${remoteManga.title}" }
+                            }
+                        }
+
+                        // Handle non-favorites
+                        !remoteManga.favorite -> {
+                            logger.debug { "Adding to non-favorites: ${remoteManga.title}" }
+                            nonFavorites.add(remoteManga)
+                        }
+                    }
+                }
+            }
+
+        logger.debug {
+            "Filtering completed in $elapsedTime. Favorites found: ${favorites.size}, Non-favorites found: ${nonFavorites.size}"
+        }
+
+        return Pair(favorites, nonFavorites)
+    }
+
+    private fun updateNonFavorites(nonFavorites: List<BackupManga>) {
+        nonFavorites.forEach { nonFavorite ->
+            val localManga =
+                transaction {
+                    MangaTable
+                        .selectAll()
+                        .where {
+                            (MangaTable.sourceReference eq nonFavorite.source) and
+                                (MangaTable.url eq nonFavorite.url)
+                        }.limit(1)
+                        .map { MangaTable.toDataClass(it) }
+                        .firstOrNull()
+                }
+
+            if (localManga != null) {
+                if (localManga.inLibrary != nonFavorite.favorite) {
+                    transaction {
+                        MangaTable.update({ MangaTable.id eq localManga.id }) {
+                            it[inLibrary] = nonFavorite.favorite
+                        }
+                    }.apply {
+                        handleMangaThumbnail(localManga.id, nonFavorite.favorite)
+                    }
+                }
+            }
+        }
+    }
+
+    sealed class SyncState(
+        open val startDate: Instant,
+    ) {
+        data class Started(
+            override val startDate: Instant,
+        ) : SyncState(startDate)
+
+        data class CreatingBackup(
+            override val startDate: Instant,
+        ) : SyncState(startDate)
+
+        data class Downloading(
+            override val startDate: Instant,
+        ) : SyncState(startDate)
+
+        data class Merging(
+            override val startDate: Instant,
+        ) : SyncState(startDate)
+
+        data class Uploading(
+            override val startDate: Instant,
+        ) : SyncState(startDate)
+
+        data class Restoring(
+            override val startDate: Instant,
+            val restoreId: String,
+        ) : SyncState(startDate)
+
+        data class Success(
+            override val startDate: Instant,
+            val endDate: Instant = Clock.System.now(),
+        ) : SyncState(startDate)
+
+        data class Error(
+            override val startDate: Instant,
+            val message: String,
+            val endDate: Instant = Clock.System.now(),
+        ) : SyncState(startDate)
+    }
+}

server/src/main/kotlin/suwayomi/tachidesk/global/impl/sync/SyncYomiSyncService.kt

@@ -0,0 +1,517 @@
+package suwayomi.tachidesk.global.impl.sync
+
+import android.app.Application
+import android.content.Context
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.network.NetworkHelper
+import eu.kanade.tachiyomi.network.PUT
+import eu.kanade.tachiyomi.network.await
+import io.github.oshai.kotlinlogging.KotlinLogging
+import io.javalin.http.HttpStatus
+import kotlinx.serialization.SerializationException
+import kotlinx.serialization.protobuf.ProtoBuf
+import okhttp3.Headers
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.RequestBody.Companion.toRequestBody
+import suwayomi.tachidesk.manga.impl.backup.proto.models.Backup
+import suwayomi.tachidesk.manga.impl.backup.proto.models.BackupCategory
+import suwayomi.tachidesk.manga.impl.backup.proto.models.BackupChapter
+import suwayomi.tachidesk.manga.impl.backup.proto.models.BackupManga
+import suwayomi.tachidesk.manga.impl.backup.proto.models.BackupSource
+import suwayomi.tachidesk.server.serverConfig
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import uy.kohesive.injekt.injectLazy
+import kotlin.time.Duration.Companion.milliseconds
+import kotlin.time.Duration.Companion.seconds
+import kotlin.time.Instant
+
+object SyncYomiSyncService {
+    private val syncPreferences = Injekt.get<Application>().getSharedPreferences("sync", Context.MODE_PRIVATE)
+
+    private val network: NetworkHelper by injectLazy()
+    private val logger = KotlinLogging.logger {}
+
+    private class SyncYomiException(
+        message: String?,
+    ) : Exception(message)
+
+    suspend fun doSync(
+        syncData: SyncData,
+        startDate: Instant,
+        setSyncState: (SyncManager.SyncState) -> Unit,
+    ): Backup? {
+        setSyncState(SyncManager.SyncState.Downloading(startDate))
+        val (remoteData, etag) = pullSyncData()
+
+        val finalSyncData =
+            if (remoteData != null) {
+                require(etag.isNotEmpty()) { "ETag should never be empty if remote data is not null" }
+                logger.debug { "Try update remote data with ETag($etag)" }
+                setSyncState(SyncManager.SyncState.Merging(startDate))
+                mergeSyncData(syncData, remoteData)
+            } else {
+                // init or overwrite remote data
+                logger.debug { "Try overwrite remote data with ETag($etag)" }
+                syncData
+            }
+
+        if (finalSyncData.backup != null) {
+            setSyncState(SyncManager.SyncState.Uploading(startDate))
+        }
+        pushSyncData(finalSyncData, etag)
+        return finalSyncData.backup
+    }
+
+    private suspend fun pullSyncData(): Pair<SyncData?, String> {
+        val host = serverConfig.syncYomiHost.value
+        val apiKey = serverConfig.syncYomiApiKey.value
+        val downloadUrl = "$host/api/sync/content"
+
+        val headersBuilder = Headers.Builder().add("X-API-Token", apiKey)
+        val lastETag = syncPreferences.getString("last_sync_etag", "") ?: ""
+        if (lastETag != "") {
+            headersBuilder.add("If-None-Match", lastETag)
+        }
+        val headers = headersBuilder.build()
+
+        val downloadRequest =
+            GET(
+                url = downloadUrl,
+                headers = headers,
+            )
+
+        val response = network.client.newCall(downloadRequest).await()
+
+        if (response.code == HttpStatus.NOT_MODIFIED.code) {
+            // not modified
+            require(lastETag.isNotEmpty())
+            logger.info { "Remote server not modified" }
+            return Pair(null, lastETag)
+        } else if (response.code == HttpStatus.NOT_FOUND.code) {
+            // maybe got deleted from remote
+            return Pair(null, "")
+        }
+
+        if (response.isSuccessful) {
+            val newETag =
+                response.headers["ETag"]
+                    ?.takeIf { it.isNotEmpty() } ?: throw SyncYomiException("Missing ETag")
+
+            val byteArray =
+                response.body.byteStream().use {
+                    return@use it.readBytes()
+                }
+
+            return try {
+                val backup = ProtoBuf.decodeFromByteArray(Backup.serializer(), byteArray)
+                return Pair(SyncData(backup = backup), newETag)
+            } catch (_: SerializationException) {
+                logger.info { "Bad content responsed from server" }
+                // the body is invalid
+                // return default value so we can overwrite it
+                Pair(null, "")
+            }
+        } else {
+            val responseBody = response.body.string()
+            logger.error { "SyncError: $responseBody" }
+            throw SyncYomiException("Failed to download sync data: $responseBody")
+        }
+    }
+
+    private suspend fun pushSyncData(
+        syncData: SyncData,
+        eTag: String,
+    ) {
+        val backup = syncData.backup ?: return
+
+        val host = serverConfig.syncYomiHost.value
+        val apiKey = serverConfig.syncYomiApiKey.value
+        val uploadUrl = "$host/api/sync/content"
+
+        val headersBuilder = Headers.Builder().add("X-API-Token", apiKey)
+        if (eTag.isNotEmpty()) {
+            headersBuilder.add("If-Match", eTag)
+        }
+        val headers = headersBuilder.build()
+
+        // Set timeout to 30 seconds
+        val timeout = 30.seconds
+        val client =
+            network.client
+                .newBuilder()
+                .connectTimeout(timeout)
+                .readTimeout(timeout)
+                .writeTimeout(timeout)
+                .build()
+
+        val byteArray = ProtoBuf.encodeToByteArray(Backup.serializer(), backup)
+        if (byteArray.isEmpty()) {
+            throw IllegalStateException("Empty backup error")
+        }
+        val body = byteArray.toRequestBody("application/octet-stream".toMediaType())
+
+        val uploadRequest =
+            PUT(
+                url = uploadUrl,
+                headers = headers,
+                body = body,
+            )
+
+        val response = client.newCall(uploadRequest).await()
+
+        if (response.isSuccessful) {
+            val newETag =
+                response.headers["ETag"]
+                    ?.takeIf { it.isNotEmpty() } ?: throw SyncYomiException("Missing ETag")
+            syncPreferences
+                .edit()
+                .putString("last_sync_etag", newETag)
+                .apply()
+            logger.debug { "SyncYomi sync completed" }
+        } else if (response.code == HttpStatus.PRECONDITION_FAILED.code) {
+            // other clients updated remote data, will try next time
+            logger.debug { "SyncYomi sync failed with 412" }
+        } else {
+            val responseBody = response.body.string()
+            logger.error { "SyncError: $responseBody" }
+        }
+    }
+
+    fun mergeSyncData(
+        localSyncData: SyncData,
+        remoteSyncData: SyncData,
+    ): SyncData {
+        val mergedCategoriesList =
+            mergeCategoriesLists(localSyncData.backup?.backupCategories, remoteSyncData.backup?.backupCategories)
+
+        val mergedMangaList =
+            mergeMangaLists(
+                localSyncData.backup?.backupManga,
+                remoteSyncData.backup?.backupManga,
+                localSyncData.backup?.backupCategories ?: emptyList(),
+                remoteSyncData.backup?.backupCategories ?: emptyList(),
+                mergedCategoriesList,
+            )
+
+        val mergedSourcesList =
+            mergeSourcesLists(localSyncData.backup?.backupSources, remoteSyncData.backup?.backupSources)
+
+        // Create the merged Backup object
+        val mergedBackup =
+            Backup(
+                backupManga = mergedMangaList,
+                backupCategories = mergedCategoriesList,
+                backupSources = mergedSourcesList,
+                meta = emptyMap(),
+                serverSettings = null,
+            )
+
+        // Create the merged SData object
+        return SyncData(
+            backup = mergedBackup,
+        )
+    }
+
+    private fun mergeMangaLists(
+        localMangaList: List<BackupManga>?,
+        remoteMangaList: List<BackupManga>?,
+        localCategories: List<BackupCategory>,
+        remoteCategories: List<BackupCategory>,
+        mergedCategories: List<BackupCategory>,
+    ): List<BackupManga> {
+        val localMangaListSafe = localMangaList.orEmpty()
+        val remoteMangaListSafe = remoteMangaList.orEmpty()
+
+        logger.debug { "Starting merge. Local list size: ${localMangaListSafe.size}, Remote list size: ${remoteMangaListSafe.size}" }
+
+        fun mangaCompositeKey(manga: BackupManga): String =
+            "${manga.source}|${manga.url}|${manga.title.lowercase().trim()}|${manga.author?.lowercase()?.trim()}"
+
+        // Create maps using composite keys
+        val localMangaMap = localMangaListSafe.associateBy { mangaCompositeKey(it) }
+        val remoteMangaMap = remoteMangaListSafe.associateBy { mangaCompositeKey(it) }
+
+        val localCategoriesMapByOrder = localCategories.associateBy { it.order }
+        val remoteCategoriesMapByOrder = remoteCategories.associateBy { it.order }
+        val mergedCategoriesMapByName = mergedCategories.associateBy { it.name }
+
+        fun updateCategories(
+            theManga: BackupManga,
+            theMap: Map<Int, BackupCategory>,
+        ): BackupManga =
+            theManga.copy(
+                categories =
+                    theManga.categories.mapNotNull {
+                        theMap[it]?.let { category ->
+                            mergedCategoriesMapByName[category.name]?.order
+                        }
+                    },
+            )
+
+        val lastSyncTime = syncPreferences.getLong("last_sync_timestamp", 0).milliseconds.inWholeSeconds
+
+        val mergedList =
+            (localMangaMap.keys + remoteMangaMap.keys).distinct().mapNotNull { compositeKey ->
+                val local = localMangaMap[compositeKey]
+                val remote = remoteMangaMap[compositeKey]
+
+                // New version comparison logic
+                when {
+                    local != null && remote == null -> {
+                        if (lastSyncTime == 0L || local.lastModifiedAt > lastSyncTime) {
+                            updateCategories(local, localCategoriesMapByOrder)
+                        } else {
+                            logger.debug { "Dropping local manga deleted on remote: ${local.title}." }
+                            null
+                        }
+                    }
+
+                    local == null && remote != null -> {
+                        if (lastSyncTime == 0L || remote.lastModifiedAt > lastSyncTime) {
+                            updateCategories(remote, remoteCategoriesMapByOrder)
+                        } else {
+                            logger.debug { "Dropping deleted remote manga: ${remote.title}." }
+                            null
+                        }
+                    }
+
+                    local != null && remote != null -> {
+                        // Compare versions to decide which manga to keep
+                        if (local.version >= remote.version) {
+                            logger.debug { "Keeping local version of ${local.title} with merged chapters." }
+                            updateCategories(
+                                local.copy(
+                                    chapters =
+                                        mergeChapters(
+                                            local.chapters,
+                                            remote.chapters,
+                                            lastSyncTime,
+                                            serverConfig.syncDataChapters.value,
+                                        ),
+                                ),
+                                localCategoriesMapByOrder,
+                            )
+                        } else {
+                            logger.debug { "Keeping remote version of ${remote.title} with merged chapters." }
+                            updateCategories(
+                                remote.copy(
+                                    chapters =
+                                        mergeChapters(
+                                            local.chapters,
+                                            remote.chapters,
+                                            lastSyncTime,
+                                            serverConfig.syncDataChapters.value,
+                                        ),
+                                ),
+                                remoteCategoriesMapByOrder,
+                            )
+                        }
+                    }
+
+                    else -> {
+                        null
+                    } // No manga found for key
+                }
+            }
+
+        // Counting favorites and non-favorites
+        val (favorites, nonFavorites) = mergedList.partition { it.favorite }
+
+        logger.debug {
+            "Merge completed. Total merged manga: ${mergedList.size}, Favorites: ${favorites.size}, Non-Favorites: ${nonFavorites.size}"
+        }
+
+        return mergedList
+    }
+
+    private fun mergeChapters(
+        localChapters: List<BackupChapter>,
+        remoteChapters: List<BackupChapter>,
+        lastSyncTime: Long,
+        syncingChapters: Boolean,
+    ): List<BackupChapter> {
+        if (!syncingChapters) {
+            return remoteChapters // If not syncing chapters, keep remote untouched
+        }
+
+        fun chapterCompositeKey(chapter: BackupChapter): String = "${chapter.url}|${chapter.name}|${chapter.chapterNumber}"
+
+        val localChapterMap = localChapters.associateBy { chapterCompositeKey(it) }
+        val remoteChapterMap = remoteChapters.associateBy { chapterCompositeKey(it) }
+
+        logger.debug { "Starting chapter merge. Local chapters: ${localChapters.size}, Remote chapters: ${remoteChapters.size}" }
+
+        // Merge both chapter maps based on version numbers
+        val mergedChapters =
+            (localChapterMap.keys + remoteChapterMap.keys).distinct().mapNotNull { compositeKey ->
+                val localChapter = localChapterMap[compositeKey]
+                val remoteChapter = remoteChapterMap[compositeKey]
+
+                logger.debug {
+                    "Processing chapter key: $compositeKey. Local chapter: ${localChapter != null}, Remote chapter: ${remoteChapter != null}"
+                }
+
+                when {
+                    localChapter != null && remoteChapter == null -> {
+                        if (lastSyncTime == 0L || localChapter.lastModifiedAt > lastSyncTime) {
+                            logger.debug { "Keeping local chapter: ${localChapter.name}." }
+                            localChapter
+                        } else {
+                            logger.debug { "Dropping local chapter deleted on remote: ${localChapter.name}." }
+                            null
+                        }
+                    }
+
+                    localChapter == null && remoteChapter != null -> {
+                        if (lastSyncTime == 0L || remoteChapter.lastModifiedAt > lastSyncTime) {
+                            logger.debug { "Taking remote chapter: ${remoteChapter.name}." }
+                            remoteChapter
+                        } else {
+                            logger.debug { "Dropping deleted remote chapter: ${remoteChapter.name}." }
+                            null
+                        }
+                    }
+
+                    localChapter != null && remoteChapter != null -> {
+                        // Use version number to decide which chapter to keep
+                        val chosenChapter =
+                            if (localChapter.version >= remoteChapter.version) {
+                                // If there mare more chapter on remote, local sourceOrder will need to be updated to maintain correct source order.
+                                if (localChapters.size < remoteChapters.size) {
+                                    localChapter.copy(sourceOrder = remoteChapter.sourceOrder)
+                                } else {
+                                    localChapter
+                                }
+                            } else {
+                                remoteChapter
+                            }
+                        logger.debug {
+                            "Merging chapter: ${chosenChapter.name}. Chosen version from: ${if (localChapter.version >= remoteChapter.version) "Local" else "Remote"}, Local version: ${localChapter.version}, Remote version: ${remoteChapter.version}."
+                        }
+                        chosenChapter
+                    }
+
+                    else -> {
+                        logger.debug { "No chapter found for composite key: $compositeKey. Skipping." }
+                        null
+                    }
+                }
+            }
+
+        logger.debug { "Chapter merge completed. Total merged chapters: ${mergedChapters.size}" }
+
+        return mergedChapters
+    }
+
+    private fun mergeCategoriesLists(
+        localCategoriesList: List<BackupCategory>?,
+        remoteCategoriesList: List<BackupCategory>?,
+    ): List<BackupCategory> {
+        if (localCategoriesList == null) return remoteCategoriesList ?: emptyList()
+        if (remoteCategoriesList == null) return localCategoriesList
+        val result = mutableListOf<BackupCategory>()
+        val processedLocals = mutableSetOf<BackupCategory>()
+
+        val localMapByUid = localCategoriesList.filter { it.uid != 0L }.associateBy { it.uid }
+        val localMapByName = localCategoriesList.associateBy { it.name }
+
+        val lastSyncTime = syncPreferences.getLong("last_sync_timestamp", 0)
+
+        remoteCategoriesList.forEach { remote ->
+            var localMatch: BackupCategory? = null
+
+            // 1. Try match by UID
+            if (remote.uid != 0L) {
+                localMatch = localMapByUid[remote.uid]
+            }
+
+            // 2. Try match by Name (fallback)
+            if (localMatch == null) {
+                localMatch = localMapByName[remote.name]
+            }
+
+            if (localMatch != null) {
+                processedLocals.add(localMatch)
+                // Conflict resolution
+                if (localMatch.version >= remote.version) {
+                    logger.debug { "Keeping local category: ${localMatch.name} (UID: ${localMatch.uid})" }
+                    result.add(localMatch)
+                } else {
+                    logger.debug { "Keeping remote category: ${remote.name} (UID: ${remote.uid})" }
+                    // Preserve Local UID if Remote was 0
+                    if (remote.uid == 0L) {
+                        remote.uid = localMatch.uid
+                    }
+                    result.add(remote)
+                }
+            } else {
+                val remoteModifiedTimeMillis = remote.lastModifiedAt.seconds.inWholeMilliseconds
+                if (lastSyncTime == 0L || remoteModifiedTimeMillis > lastSyncTime) {
+                    logger.debug { "Adding new remote category: ${remote.name} (UID: ${remote.uid})" }
+                    result.add(remote)
+                } else {
+                    logger.debug { "Dropping deleted remote category: ${remote.name} (UID: ${remote.uid})" }
+                }
+            }
+        }
+
+        // Add remaining Local Categories
+        localCategoriesList.forEach { local ->
+            if (local !in processedLocals) {
+                val localModifiedTimeMillis = local.lastModifiedAt.seconds.inWholeMilliseconds
+                if (lastSyncTime == 0L || localModifiedTimeMillis > lastSyncTime) {
+                    logger.debug { "Keeping local only category: ${local.name} (UID: ${local.uid})" }
+                    result.add(local)
+                } else {
+                    logger.debug { "Dropping local category deleted on remote: ${local.name} (UID: ${local.uid})" }
+                }
+            }
+        }
+
+        return result.sortedBy { it.order }
+    }
+
+    private fun mergeSourcesLists(
+        localSources: List<BackupSource>?,
+        remoteSources: List<BackupSource>?,
+    ): List<BackupSource> {
+        // Create maps using sourceId as key
+        val localSourceMap = localSources?.associateBy { it.sourceId } ?: emptyMap()
+        val remoteSourceMap = remoteSources?.associateBy { it.sourceId } ?: emptyMap()
+
+        logger.debug { "Starting source merge. Local sources: ${localSources?.size}, Remote sources: ${remoteSources?.size}" }
+
+        // Merge both source maps
+        val mergedSources =
+            (localSourceMap.keys + remoteSourceMap.keys).distinct().mapNotNull { sourceId ->
+                val localSource = localSourceMap[sourceId]
+                val remoteSource = remoteSourceMap[sourceId]
+
+                logger.debug {
+                    "Processing source ID: $sourceId. Local source: ${localSource != null}, Remote source: ${remoteSource != null}"
+                }
+
+                when {
+                    localSource != null && remoteSource == null -> {
+                        logger.debug { "Using local source: ${localSource.name}." }
+                        localSource
+                    }
+
+                    remoteSource != null && localSource == null -> {
+                        logger.debug { "Using remote source: ${remoteSource.name}." }
+                        remoteSource
+                    }
+
+                    else -> {
+                        logger.debug { "Remote and local have the same source ID: $sourceId. Keeping local." }
+                        localSource
+                    }
+                }
+            }
+
+        logger.debug { "Source merge completed. Total merged sources: ${mergedSources.size}" }
+
+        return mergedSources
+    }
+}

server/src/main/kotlin/suwayomi/tachidesk/global/model/table/GlobalMetaTable.kt

@@ -13,6 +13,6 @@ import org.jetbrains.exposed.v1.core.dao.id.IntIdTable
  * Metadata storage for clients, server/global level.
  */
 object GlobalMetaTable : IntIdTable() {
-    val key = varchar("key", 256)
+    val key = varchar("meta_key", 256)
     val value = varchar("value", 4096)
 }

server/src/main/kotlin/suwayomi/tachidesk/graphql/mutations/SyncMutation.kt

@@ -0,0 +1,28 @@
+package suwayomi.tachidesk.graphql.mutations
+
+import suwayomi.tachidesk.global.impl.sync.SyncManager
+import suwayomi.tachidesk.graphql.directives.RequireAuth
+import suwayomi.tachidesk.graphql.types.StartSyncResult
+
+class SyncMutation {
+    data class StartSyncInput(
+        val clientMutationId: String? = null,
+    )
+
+    data class StartSyncPayload(
+        val clientMutationId: String? = null,
+        val result: StartSyncResult,
+    )
+
+    @RequireAuth
+    fun startSync(input: StartSyncInput): StartSyncPayload {
+        val (clientMutationId) = input
+
+        val result = SyncManager.startSync()
+
+        return StartSyncPayload(
+            clientMutationId = clientMutationId,
+            result = result,
+        )
+    }
+}

server/src/main/kotlin/suwayomi/tachidesk/graphql/queries/MangaQuery.kt

@@ -15,9 +15,11 @@ import org.jetbrains.exposed.v1.core.Op
 import org.jetbrains.exposed.v1.core.SortOrder
 import org.jetbrains.exposed.v1.core.greater
 import org.jetbrains.exposed.v1.core.inList
+import org.jetbrains.exposed.v1.core.inSubQuery
 import org.jetbrains.exposed.v1.core.less
 import org.jetbrains.exposed.v1.core.like
 import org.jetbrains.exposed.v1.jdbc.select
+import org.jetbrains.exposed.v1.jdbc.selectAll
 import org.jetbrains.exposed.v1.jdbc.transactions.transaction
 import suwayomi.tachidesk.graphql.directives.RequireAuth
 import suwayomi.tachidesk.graphql.queries.filter.BooleanFilter
@@ -243,13 +245,16 @@ class MangaQuery {
     ): MangaNodeList {
         val queryResults =
             transaction {
-                val res =
+                val mangaIdsQuery =
                     MangaTable
                         .leftJoin(CategoryMangaTable)
-                        .select(MangaTable.columns)
-                        .withDistinctOn(MangaTable.id)
+                        .select(MangaTable.id)
+                        .withDistinct()
 
-                res.applyOps(condition, filter)
+                mangaIdsQuery.applyOps(condition, filter)
+
+                val res =
+                    MangaTable.selectAll().where { MangaTable.id inSubQuery mangaIdsQuery }
 
                 if (order != null || orderBy != null || (last != null || before != null)) {
                     val baseSort = listOf(MangaOrder(MangaOrderBy.ID, SortOrder.ASC))

server/src/main/kotlin/suwayomi/tachidesk/graphql/queries/SyncQuery.kt

@@ -0,0 +1,11 @@
+package suwayomi.tachidesk.graphql.queries
+
+import suwayomi.tachidesk.global.impl.sync.SyncManager
+import suwayomi.tachidesk.graphql.directives.RequireAuth
+import suwayomi.tachidesk.graphql.types.SyncStatus
+import suwayomi.tachidesk.graphql.types.toStatus
+
+class SyncQuery {
+    @RequireAuth
+    fun lastSyncStatus(): SyncStatus? = SyncManager.lastSyncState.value?.toStatus()
+}

server/src/main/kotlin/suwayomi/tachidesk/graphql/queries/filter/Filter.kt

@@ -435,7 +435,7 @@ fun <T : String, S : T?> andFilterWithCompareString(
 
     opAnd.andWhere(filter.isNull) { if (it) column.isNull() else column.isNotNull() }
     opAnd.andWhere(filter.equalTo) { column eq it as S }
-    opAnd.andWhere(filter.notEqualTo, filter.notEqualToAll, filter.notEqualToAny) { column neq it as S }
+    opAnd.andNotWhere(filter.notEqualTo, filter.notEqualToAll, filter.notEqualToAny) { column neq it as S }
     opAnd.andWhere(
         filter.distinctFrom,
         filter.distinctFromAll,
@@ -455,36 +455,36 @@ fun <T : String, S : T?> andFilterWithCompareString(
     opAnd.andWhere(filter.greaterThanOrEqualTo) { column greaterEq it }
 
     opAnd.andWhere(filter.includes, filter.includesAll, filter.includesAny) { column like "%$it%" }
-    opAnd.andWhere(filter.notIncludes, filter.notIncludesAll, filter.notIncludesAny) { column notLike "%$it%" }
+    opAnd.andNotWhere(filter.notIncludes, filter.notIncludesAll, filter.notIncludesAny) { column notLike "%$it%" }
     opAnd.andWhere(filter.includesInsensitive, filter.includesInsensitiveAll, filter.includesInsensitiveAny) {
         ILikeEscapeOp.iLike(column, "%$it%")
     }
-    opAnd.andWhere(filter.notIncludesInsensitive, filter.notIncludesInsensitiveAll, filter.notIncludesInsensitiveAny) {
+    opAnd.andNotWhere(filter.notIncludesInsensitive, filter.notIncludesInsensitiveAll, filter.notIncludesInsensitiveAny) {
         ILikeEscapeOp.iNotLike(column, "%$it%")
     }
 
     opAnd.andWhere(filter.startsWith, filter.startsWithAll, filter.startsWithAny) { column like "$it%" }
-    opAnd.andWhere(filter.notStartsWith, filter.notStartsWithAll, filter.notStartsWithAny) { column notLike "$it%" }
+    opAnd.andNotWhere(filter.notStartsWith, filter.notStartsWithAll, filter.notStartsWithAny) { column notLike "$it%" }
     opAnd.andWhere(filter.startsWithInsensitive, filter.startsWithInsensitiveAll, filter.startsWithInsensitiveAny) {
         ILikeEscapeOp.iLike(column, "$it%")
     }
-    opAnd.andWhere(filter.notStartsWithInsensitive, filter.notStartsWithInsensitiveAll, filter.notStartsWithInsensitiveAny) {
+    opAnd.andNotWhere(filter.notStartsWithInsensitive, filter.notStartsWithInsensitiveAll, filter.notStartsWithInsensitiveAny) {
         ILikeEscapeOp.iNotLike(column, "$it%")
     }
 
     opAnd.andWhere(filter.endsWith, filter.endsWithAll, filter.endsWithAny) { column like "%$it" }
-    opAnd.andWhere(filter.notEndsWith, filter.notEndsWithAll, filter.notEndsWithAny) { column notLike "%$it" }
+    opAnd.andNotWhere(filter.notEndsWith, filter.notEndsWithAll, filter.notEndsWithAny) { column notLike "%$it" }
     opAnd.andWhere(filter.endsWithInsensitive, filter.endsWithInsensitiveAll, filter.endsWithInsensitiveAny) {
         ILikeEscapeOp.iLike(column, "%$it")
     }
-    opAnd.andWhere(filter.notEndsWithInsensitive, filter.notEndsWithInsensitiveAll, filter.notEndsWithInsensitiveAny) {
+    opAnd.andNotWhere(filter.notEndsWithInsensitive, filter.notEndsWithInsensitiveAll, filter.notEndsWithInsensitiveAny) {
         ILikeEscapeOp.iNotLike(column, "%$it")
     }
 
     opAnd.andWhere(filter.like, filter.likeAll, filter.likeAny) { column like it }
-    opAnd.andWhere(filter.notLike, filter.notLikeAll, filter.notLikeAny) { column notLike it }
+    opAnd.andNotWhere(filter.notLike, filter.notLikeAll, filter.notLikeAny) { column notLike it }
     opAnd.andWhere(filter.likeInsensitive, filter.likeInsensitiveAll, filter.likeInsensitiveAny) { ILikeEscapeOp.iLike(column, it) }
-    opAnd.andWhere(filter.notLikeInsensitive, filter.notLikeInsensitiveAll, filter.notLikeInsensitiveAny) {
+    opAnd.andNotWhere(filter.notLikeInsensitive, filter.notLikeInsensitiveAll, filter.notLikeInsensitiveAny) {
         ILikeEscapeOp.iNotLike(column, it)
     }
 
@@ -535,6 +535,17 @@ class OpAnd(
         andWhereAny(valueAny, expr)
     }
 
+    fun <T : Any> andNotWhere(
+        valueDefault: T?,
+        valueAll: List<T>?,
+        valueAny: List<T>?,
+        expr: (T) -> Op<Boolean>,
+    ) {
+        andWhere(valueDefault, expr)
+        andNotWhereAll(valueAll, expr)
+        andNotWhereAny(valueAny, expr)
+    }
+
     fun <T : Any> andWhereAll(
         values: List<T>?,
         andPart: (T) -> Op<Boolean>,
@@ -542,15 +553,31 @@ class OpAnd(
         values?.map { andWhere(it, andPart) }
     }
 
+    fun <T : Any> andNotWhereAll(
+        values: List<T>?,
+        andPart: (T) -> Op<Boolean>,
+    ) {
+        // Inversed all equals any
+        andWhereAny(values, andPart)
+    }
+
     fun <T : Any> andWhereAny(
         values: List<T>?,
         andPart: (T) -> Op<Boolean>,
     ) {
         values ?: return
-        val expr = values.map { andPart(it) }.reduce { acc, op -> acc or op }
+        val expr = values.map { andPart(it) }.reduceOrNull { acc, op -> acc or op } ?: return
         op = if (op == null) expr else (op!! and expr)
     }
 
+    fun <T : Any> andNotWhereAny(
+        values: List<T>?,
+        andPart: (T) -> Op<Boolean>,
+    ) {
+        // Inversed any equals all
+        andWhereAll(values, andPart)
+    }
+
     fun <T> eq(
         value: T?,
         column: Column<T>,
@@ -578,7 +605,7 @@ fun <T : Comparable<T>, S : T?> andFilterWithCompare(
     opAnd.andWhere(filter.isNull) { if (it) column.isNull() else column.isNotNull() }
 
     opAnd.andWhere(filter.equalTo) { column eq it as S }
-    opAnd.andWhere(filter.notEqualTo, filter.notEqualToAll, filter.notEqualToAny) { column neq it as S }
+    opAnd.andNotWhere(filter.notEqualTo, filter.notEqualToAll, filter.notEqualToAny) { column neq it as S }
     opAnd.andWhere(filter.distinctFrom, filter.distinctFromAll, filter.distinctFromAny) { DistinctFromOp.distinctFrom(column, it as S) }
     opAnd.andWhere(filter.notDistinctFrom) { DistinctFromOp.notDistinctFrom(column, it as S) }
     if (!filter.`in`.isNullOrEmpty()) {
@@ -606,7 +633,7 @@ fun <T : Comparable<T>> andFilterWithCompareEntity(
     opAnd.andWhere(filter.isNull) { if (it) column.isNull() else column.isNotNull() }
 
     opAnd.andWhere(filter.equalTo) { column eq it }
-    opAnd.andWhere(filter.notEqualTo, filter.notEqualToAll, filter.notEqualToAny) { column neq it }
+    opAnd.andNotWhere(filter.notEqualTo, filter.notEqualToAll, filter.notEqualToAny) { column neq it }
     opAnd.andWhere(filter.distinctFrom, filter.distinctFromAll, filter.distinctFromAny) { DistinctFromOp.distinctFrom(column, it) }
     opAnd.andWhere(filter.notDistinctFrom) { DistinctFromOp.notDistinctFrom(column, it) }
     if (!filter.`in`.isNullOrEmpty()) {

server/src/main/kotlin/suwayomi/tachidesk/graphql/server/TachideskGraphQLSchema.kt

@@ -27,6 +27,7 @@ import suwayomi.tachidesk.graphql.mutations.MangaMutation
 import suwayomi.tachidesk.graphql.mutations.MetaMutation
 import suwayomi.tachidesk.graphql.mutations.SettingsMutation
 import suwayomi.tachidesk.graphql.mutations.SourceMutation
+import suwayomi.tachidesk.graphql.mutations.SyncMutation
 import suwayomi.tachidesk.graphql.mutations.TrackMutation
 import suwayomi.tachidesk.graphql.mutations.UpdateMutation
 import suwayomi.tachidesk.graphql.mutations.UserMutation
@@ -41,6 +42,7 @@ import suwayomi.tachidesk.graphql.queries.MangaQuery
 import suwayomi.tachidesk.graphql.queries.MetaQuery
 import suwayomi.tachidesk.graphql.queries.SettingsQuery
 import suwayomi.tachidesk.graphql.queries.SourceQuery
+import suwayomi.tachidesk.graphql.queries.SyncQuery
 import suwayomi.tachidesk.graphql.queries.TrackQuery
 import suwayomi.tachidesk.graphql.queries.UpdateQuery
 import suwayomi.tachidesk.graphql.server.primitives.Cursor
@@ -50,6 +52,7 @@ import suwayomi.tachidesk.graphql.server.primitives.GraphQLLongAsString
 import suwayomi.tachidesk.graphql.server.primitives.GraphQLUpload
 import suwayomi.tachidesk.graphql.subscriptions.DownloadSubscription
 import suwayomi.tachidesk.graphql.subscriptions.InfoSubscription
+import suwayomi.tachidesk.graphql.subscriptions.SyncSubscription
 import suwayomi.tachidesk.graphql.subscriptions.UpdateSubscription
 import kotlin.reflect.KClass
 import kotlin.reflect.KType
@@ -98,6 +101,7 @@ val schema =
                 TopLevelObject(MetaQuery()),
                 TopLevelObject(SettingsQuery()),
                 TopLevelObject(SourceQuery()),
+                TopLevelObject(SyncQuery()),
                 TopLevelObject(TrackQuery()),
                 TopLevelObject(UpdateQuery()),
             ),
@@ -114,6 +118,7 @@ val schema =
                 TopLevelObject(MangaMutation()),
                 TopLevelObject(MetaMutation()),
                 TopLevelObject(SettingsMutation()),
+                TopLevelObject(SyncMutation()),
                 TopLevelObject(SourceMutation()),
                 TopLevelObject(TrackMutation()),
                 TopLevelObject(UpdateMutation()),
@@ -123,6 +128,7 @@ val schema =
             listOf(
                 TopLevelObject(DownloadSubscription()),
                 TopLevelObject(InfoSubscription()),
+                TopLevelObject(SyncSubscription()),
                 TopLevelObject(UpdateSubscription()),
             ),
     )

server/src/main/kotlin/suwayomi/tachidesk/graphql/subscriptions/SyncSubscription.kt

@@ -0,0 +1,17 @@
+package suwayomi.tachidesk.graphql.subscriptions
+
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.filterNotNull
+import kotlinx.coroutines.flow.map
+import suwayomi.tachidesk.global.impl.sync.SyncManager
+import suwayomi.tachidesk.graphql.directives.RequireAuth
+import suwayomi.tachidesk.graphql.types.SyncStatus
+import suwayomi.tachidesk.graphql.types.toStatus
+
+class SyncSubscription {
+    @RequireAuth
+    fun syncStatusChanged(): Flow<SyncStatus> =
+        SyncManager.lastSyncState
+            .filterNotNull()
+            .map { it.toStatus() }
+}

server/src/main/kotlin/suwayomi/tachidesk/graphql/types/SyncType.kt

@@ -0,0 +1,91 @@
+package suwayomi.tachidesk.graphql.types
+
+import suwayomi.tachidesk.global.impl.sync.SyncManager
+
+enum class StartSyncResult {
+    SUCCESS,
+    SYNC_IN_PROGRESS,
+    SYNC_DISABLED,
+}
+
+enum class SyncState {
+    STARTED,
+    CREATING_BACKUP,
+    DOWNLOADING,
+    MERGING,
+    UPLOADING,
+    RESTORING,
+    SUCCESS,
+    ERROR,
+}
+
+data class SyncStatus(
+    val state: SyncState,
+    val startDate: Long,
+    val endDate: Long? = null,
+    val backupRestoreId: String? = null,
+    val errorMessage: String? = null,
+)
+
+fun SyncManager.SyncState.toStatus(): SyncStatus =
+    when (this) {
+        is SyncManager.SyncState.Started -> {
+            SyncStatus(
+                state = SyncState.STARTED,
+                startDate = startDate.toEpochMilliseconds(),
+            )
+        }
+
+        is SyncManager.SyncState.CreatingBackup -> {
+            SyncStatus(
+                state = SyncState.CREATING_BACKUP,
+                startDate = startDate.toEpochMilliseconds(),
+            )
+        }
+
+        is SyncManager.SyncState.Downloading -> {
+            SyncStatus(
+                state = SyncState.DOWNLOADING,
+                startDate = startDate.toEpochMilliseconds(),
+            )
+        }
+
+        is SyncManager.SyncState.Merging -> {
+            SyncStatus(
+                state = SyncState.MERGING,
+                startDate = startDate.toEpochMilliseconds(),
+            )
+        }
+
+        is SyncManager.SyncState.Uploading -> {
+            SyncStatus(
+                state = SyncState.UPLOADING,
+                startDate = startDate.toEpochMilliseconds(),
+            )
+        }
+
+        is SyncManager.SyncState.Restoring -> {
+            SyncStatus(
+                state = SyncState.RESTORING,
+                startDate = startDate.toEpochMilliseconds(),
+                backupRestoreId = restoreId,
+            )
+        }
+
+        is SyncManager.SyncState.Success -> {
+            SyncStatus(
+                state = SyncState.SUCCESS,
+                startDate = startDate.toEpochMilliseconds(),
+                endDate = endDate.toEpochMilliseconds(),
+            )
+        }
+
+        is SyncManager.SyncState.Error -> {
+            SyncStatus(
+                state = SyncState.ERROR,
+                startDate = startDate.toEpochMilliseconds(),
+                endDate = endDate.toEpochMilliseconds(),
+                errorMessage = message,
+            )
+        }
+    }

server/src/main/kotlin/suwayomi/tachidesk/manga/impl/CategoryManga.kt

@@ -85,6 +85,12 @@ object CategoryManga {
         }
     }
 
+    fun removeMangaFromAllCategories(mangaId: Int) {
+        transaction {
+            CategoryMangaTable.deleteWhere { CategoryMangaTable.manga eq mangaId }
+        }
+    }
+
     /**
      * list of mangas that belong to a category
      */

server/src/main/kotlin/suwayomi/tachidesk/manga/impl/Chapter.kt

@@ -129,6 +129,8 @@ object Chapter {
                 downloaded = dbChapter[ChapterTable.isDownloaded],
                 pageCount = dbChapter[ChapterTable.pageCount],
                 chapterCount = chapterList.size,
+                lastModifiedAt = dbChapter[ChapterTable.lastModifiedAt],
+                version = dbChapter[ChapterTable.version],
                 meta = chapterMetas.getValue(dbChapter[ChapterTable.id].value),
             )
         }
@@ -192,7 +194,7 @@ object Chapter {
                     }
 
                 // new chapters after they have been added to the database for auto downloads
-                val insertedChapters = mutableListOf<ChapterDataClass>()
+                val insertedChapterIds = mutableListOf<Int>()
 
                 val chaptersToInsert = mutableListOf<ChapterDataClass>() // do not yet have an ID from the database
                 val chaptersToUpdate = mutableListOf<ChapterDataClass>()
@@ -236,7 +238,7 @@ object Chapter {
                 val deletedChapterNumbers = TreeSet<Float>()
                 val deletedReadChapterNumbers = TreeSet<Float>()
                 val deletedBookmarkedChapterNumbers = TreeSet<Float>()
-                val deletedDownloadedChapterNumberInfoMap = mutableMapOf<Float, MutableMap<String?, Int>>()
+                val deletedDownloadedChapterNumberToChapter = mutableMapOf<Float, ChapterDataClass>()
                 val deletedChapterNumberDateFetchMap = mutableMapOf<Float, Long>()
 
                 // clear any orphaned/duplicate chapters that are in the db but not in `chapterList`
@@ -247,13 +249,7 @@ object Chapter {
                         if (!chapterUrls.contains(dbChapter.url)) {
                             if (dbChapter.read) deletedReadChapterNumbers.add(dbChapter.chapterNumber)
                             if (dbChapter.bookmarked) deletedBookmarkedChapterNumbers.add(dbChapter.chapterNumber)
-                            if (dbChapter.downloaded) {
-                                val pageCountByScanlator =
-                                    deletedDownloadedChapterNumberInfoMap.getOrPut(
-                                        dbChapter.chapterNumber,
-                                    ) { mutableMapOf() }
-                                pageCountByScanlator[dbChapter.scanlator] = dbChapter.pageCount
-                            }
+                            if (dbChapter.downloaded) deletedDownloadedChapterNumberToChapter[dbChapter.chapterNumber] = dbChapter
                             deletedChapterNumbers.add(dbChapter.chapterNumber)
                             deletedChapterNumberDateFetchMap[dbChapter.chapterNumber] = dbChapter.fetchedAt
                             dbChapter.id
@@ -262,16 +258,14 @@ object Chapter {
                         }
                     }
 
-                // we got some clean up due
-                if (chaptersIdsToDelete.isNotEmpty()) {
-                    DownloadManager.dequeue(chaptersIdsToDelete)
-                    transaction {
+                transaction {
+                    // we got some clean up due
+                    if (chaptersIdsToDelete.isNotEmpty()) {
+                        DownloadManager.dequeue(chaptersIdsToDelete)
                         PageTable.deleteWhere { chapter inList chaptersIdsToDelete }
                         ChapterTable.deleteWhere { id inList chaptersIdsToDelete }
                     }
-                }
 
-                transaction {
                     if (chaptersToInsert.isNotEmpty()) {
                         ChapterTable
                             .batchInsert(chaptersToInsert) { chapter ->
@@ -287,26 +281,35 @@ object Chapter {
                                 this[ChapterTable.isRead] = false
                                 this[ChapterTable.isBookmarked] = false
                                 this[ChapterTable.isDownloaded] = false
+                                this[ChapterTable.lastModifiedAt] = chapter.lastModifiedAt
+                                this[ChapterTable.version] = chapter.version
+                                this[ChapterTable.pageCount] = -1
 
                                 // is recognized chapter number
                                 if (chapter.chapterNumber >= 0f && chapter.chapterNumber in deletedChapterNumbers) {
                                     this[ChapterTable.isRead] = chapter.chapterNumber in deletedReadChapterNumbers
                                     this[ChapterTable.isBookmarked] = chapter.chapterNumber in deletedBookmarkedChapterNumbers
 
-                                    // only preserve download status for chapters of the same scanlator, otherwise,
-                                    // the downloaded files won't be found anyway
-                                    val downloadedChapterInfo = deletedDownloadedChapterNumberInfoMap[chapter.chapterNumber]
-                                    val pageCount = downloadedChapterInfo?.get(chapter.scanlator)
-                                    if (pageCount != null) {
-                                        this[ChapterTable.isDownloaded] = true
-                                        this[ChapterTable.pageCount] = pageCount
-                                    }
                                     // Try to use the fetch date of the original entry to not pollute 'Updates' tab
                                     deletedChapterNumberDateFetchMap[chapter.chapterNumber]?.let {
                                         this[ChapterTable.fetchedAt] = it
                                     }
+
+                                    deletedDownloadedChapterNumberToChapter[chapter.chapterNumber]?.let {
+                                        val hasDownloadedPages = it.pageCount > 0
+                                        val isSameName = it.name == chapter.name
+                                        val isSameScanlator = it.scanlator == chapter.scanlator
+
+                                        // Only preserve download status for chapters with the same name and of the same scanlator; otherwise,
+                                        // the downloaded files won't be found anyway
+                                        val isDownloadPreservable = hasDownloadedPages && isSameName && isSameScanlator
+                                        if (isDownloadPreservable) {
+                                            this[ChapterTable.isDownloaded] = true
+                                            this[ChapterTable.pageCount] = it.pageCount
+                                        }
+                                    }
                                 }
-                            }.forEach { insertedChapters.add(ChapterTable.toDataClass(it)) }
+                            }.forEach { insertedChapterIds.add(it[ChapterTable.id].value) }
                     }
 
                     if (chaptersToUpdate.isNotEmpty()) {
@@ -314,12 +317,32 @@ object Chapter {
                             .apply {
                                 chaptersToUpdate.forEach {
                                     addBatch(EntityID(it.id, ChapterTable))
+
+                                    val currentChapter = chaptersInDb.find { dbChapter -> dbChapter.id == it.id }!!
+
                                     this[ChapterTable.name] = it.name
                                     this[ChapterTable.date_upload] = it.uploadDate
                                     this[ChapterTable.chapter_number] = it.chapterNumber
                                     this[ChapterTable.scanlator] = it.scanlator
                                     this[ChapterTable.sourceOrder] = it.index
                                     this[ChapterTable.realUrl] = it.realUrl
+                                    this[ChapterTable.lastModifiedAt] = it.lastModifiedAt
+                                    this[ChapterTable.version] = it.version
+                                    this[ChapterTable.isDownloaded] = currentChapter.downloaded
+                                    this[ChapterTable.pageCount] = currentChapter.pageCount
+
+                                    if (!currentChapter.downloaded) {
+                                        return@forEach
+                                    }
+
+                                    val isSameScanlator = currentChapter.scanlator == it.scanlator
+                                    val isSameName = currentChapter.name == it.name
+
+                                    val isDownloadPreservable = isSameName && isSameScanlator
+                                    if (!isDownloadPreservable) {
+                                        this[ChapterTable.isDownloaded] = false
+                                        this[ChapterTable.pageCount] = -1
+                                    }
                                 }
                             }.toExecutable()
                             .execute(this@transaction)
@@ -331,6 +354,13 @@ object Chapter {
                 }
 
                 if (manga.inLibrary) {
+                    // We have to query the inserted chapters to get the up-to-date data. I.e. "last_modified_at" is not returned by the insert statement, due to being set by a DB trigger
+                    val insertedChapters =
+                        transaction {
+                            ChapterTable.selectAll().where { ChapterTable.id inList insertedChapterIds }.map(
+                                ChapterTable::toDataClass,
+                            )
+                        }
                     downloadNewChapters(mangaId, currentLatestChapterNumber, numberOfCurrentChapters, insertedChapters)
                 }
 

server/src/main/kotlin/suwayomi/tachidesk/manga/impl/Manga.kt

@@ -99,6 +99,8 @@ object Manga {
                 updateStrategy = UpdateStrategy.valueOf(mangaEntry[MangaTable.updateStrategy]),
                 freshData = true,
                 trackers = Track.getTrackRecordsByMangaId(mangaId),
+                lastModifiedAt = mangaEntry[MangaTable.lastModifiedAt],
+                version = mangaEntry[MangaTable.version],
             )
         }
     }
@@ -133,7 +135,7 @@ object Manga {
                         ""
                     }
                 if (remoteTitle.isNotEmpty() && remoteTitle != mangaEntry[MangaTable.title]) {
-                    val canUpdateTitle = updateMangaDownloadDir(mangaId, remoteTitle)
+                    val canUpdateTitle = updateMangaDownloadDir(mangaEntry[MangaTable.title], source.toString(), remoteTitle)
 
                     if (canUpdateTitle) {
                         it[MangaTable.title] = remoteTitle
@@ -246,6 +248,8 @@ object Manga {
         updateStrategy = UpdateStrategy.valueOf(mangaEntry[MangaTable.updateStrategy]),
         freshData = false,
         trackers = Track.getTrackRecordsByMangaId(mangaId),
+        lastModifiedAt = mangaEntry[MangaTable.lastModifiedAt],
+        version = mangaEntry[MangaTable.version],
     )
 
     fun getMangaMetaMap(mangaId: Int): Map<String, String> =

server/src/main/kotlin/suwayomi/tachidesk/manga/impl/backup/proto/ProtoBackupImport.kt

@@ -21,6 +21,9 @@ import kotlinx.coroutines.sync.withLock
 import okio.buffer
 import okio.gzip
 import okio.source
+import org.jetbrains.exposed.v1.core.eq
+import org.jetbrains.exposed.v1.jdbc.transactions.transaction
+import org.jetbrains.exposed.v1.jdbc.update
 import suwayomi.tachidesk.graphql.types.toStatus
 import suwayomi.tachidesk.manga.impl.backup.BackupFlags
 import suwayomi.tachidesk.manga.impl.backup.proto.ProtoBackupValidator.ValidationResult
@@ -31,6 +34,8 @@ import suwayomi.tachidesk.manga.impl.backup.proto.handlers.BackupMangaHandler
 import suwayomi.tachidesk.manga.impl.backup.proto.handlers.BackupSettingsHandler
 import suwayomi.tachidesk.manga.impl.backup.proto.handlers.BackupSourceHandler
 import suwayomi.tachidesk.manga.impl.backup.proto.models.Backup
+import suwayomi.tachidesk.manga.model.table.ChapterTable
+import suwayomi.tachidesk.manga.model.table.MangaTable
 import java.io.InputStream
 import java.util.Date
 import java.util.Timer
@@ -109,6 +114,7 @@ object ProtoBackupImport : ProtoBackupBase() {
     fun restore(
         sourceStream: InputStream,
         flags: BackupFlags,
+        isSync: Boolean = false,
     ): String {
         val restoreId = System.currentTimeMillis().toString()
 
@@ -117,7 +123,7 @@ object ProtoBackupImport : ProtoBackupBase() {
         updateRestoreState(restoreId, BackupRestoreState.Idle)
 
         GlobalScope.launch {
-            restoreLegacy(sourceStream, restoreId, flags)
+            restoreLegacy(sourceStream, restoreId, flags, isSync)
         }
 
         return restoreId
@@ -127,11 +133,12 @@ object ProtoBackupImport : ProtoBackupBase() {
         sourceStream: InputStream,
         restoreId: String = "legacy",
         flags: BackupFlags = BackupFlags.DEFAULT,
+        isSync: Boolean = false,
     ): ValidationResult =
         backupMutex.withLock {
             try {
                 logger.info { "restore($restoreId): restoring..." }
-                performRestore(restoreId, sourceStream, flags)
+                performRestore(restoreId, sourceStream, flags, isSync)
             } catch (e: Exception) {
                 logger.error(e) { "restore($restoreId): failed due to" }
 
@@ -152,12 +159,14 @@ object ProtoBackupImport : ProtoBackupBase() {
         id: String,
         sourceStream: InputStream,
         flags: BackupFlags,
+        isSync: Boolean,
     ): ValidationResult {
         val backupString =
             sourceStream
                 .source()
-                .gzip()
-                .buffer()
+                .run {
+                    if (!isSync) gzip() else this
+                }.buffer()
                 .use { it.readByteArray() }
         val backup = parser.decodeFromByteArray(Backup.serializer(), backupString)
 
@@ -235,6 +244,17 @@ object ProtoBackupImport : ProtoBackupBase() {
             """.trimIndent()
         }
 
+        if (isSync) {
+            transaction {
+                MangaTable.update({ MangaTable.isSyncing eq true }) {
+                    it[isSyncing] = false
+                }
+                ChapterTable.update({ ChapterTable.isSyncing eq true }) {
+                    it[isSyncing] = false
+                }
+            }
+        }
+
         updateRestoreState(id, BackupRestoreState.Success)
 
         return validationResult

server/src/main/kotlin/suwayomi/tachidesk/manga/impl/backup/proto/handlers/BackupCategoryHandler.kt

@@ -8,7 +8,11 @@ package suwayomi.tachidesk.manga.impl.backup.proto.handlers
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 import org.jetbrains.exposed.v1.core.SortOrder
+import org.jetbrains.exposed.v1.core.eq
+import org.jetbrains.exposed.v1.jdbc.insertAndGetId
 import org.jetbrains.exposed.v1.jdbc.selectAll
+import org.jetbrains.exposed.v1.jdbc.transactions.transaction
+import org.jetbrains.exposed.v1.jdbc.update
 import suwayomi.tachidesk.manga.impl.Category
 import suwayomi.tachidesk.manga.impl.Category.modifyCategoriesMetas
 import suwayomi.tachidesk.manga.impl.backup.BackupFlags
@@ -38,6 +42,9 @@ object BackupCategoryHandler {
                     it.name,
                     it.order,
                     0, // not supported in Tachidesk
+                    it.version,
+                    it.uid,
+                    it.lastModifiedAt,
                 ).apply {
                     this.meta = categoryToMeta[it.id] ?: emptyMap()
                 }
@@ -45,7 +52,56 @@ object BackupCategoryHandler {
         }
 
     fun restore(backupCategories: List<BackupCategory>): Map<Int, Int> {
-        val categoryIds = Category.createCategories(backupCategories.map { it.name })
+        val dbCategories = Category.getCategoryList()
+        val dbCategoriesByName = dbCategories.associateBy { it.name }
+        val dbCategoriesByUid = dbCategories.associateBy { it.uid }
+
+        var nextOrder = dbCategories.maxOfOrNull { it.order }?.plus(1) ?: 0
+
+        val categoryIds =
+            transaction {
+                backupCategories
+                    .map { backupCategory ->
+                        var dbCategory =
+                            if (backupCategory.uid != 0L) {
+                                dbCategoriesByUid[backupCategory.uid]
+                            } else {
+                                null
+                            }
+
+                        if (dbCategory == null) {
+                            dbCategory = dbCategoriesByName[backupCategory.name]
+                        }
+
+                        if (dbCategory != null) {
+                            CategoryTable.update({ CategoryTable.id eq dbCategory.id }) {
+                                it[name] = backupCategory.name
+                                it[order] = backupCategory.order
+                                it[version] = backupCategory.version
+                                it[uid] = if (backupCategory.uid != 0L) backupCategory.uid else dbCategory.uid
+                                it[lastModifiedAt] = backupCategory.lastModifiedAt
+                                it[isSyncing] = true
+                            }
+                            return@map dbCategory.id
+                        }
+
+                        val currentOrder = nextOrder++
+                        CategoryTable
+                            .insertAndGetId {
+                                it[name] = backupCategory.name
+                                it[order] = currentOrder
+                                it[version] = backupCategory.version
+                                it[uid] = backupCategory.uid
+                                it[lastModifiedAt] = backupCategory.lastModifiedAt
+                            }.value
+                    }
+            }
+
+        transaction {
+            CategoryTable.update({ CategoryTable.isSyncing eq true }) {
+                it[isSyncing] = false
+            }
+        }
 
         val metaEntryByCategoryId =
             categoryIds

server/src/main/kotlin/suwayomi/tachidesk/manga/impl/backup/proto/handlers/BackupMangaHandler.kt

@@ -75,6 +75,8 @@ object BackupMangaHandler {
                         dateAdded = mangaRow[MangaTable.inLibraryAt].seconds.inWholeMilliseconds,
                         viewer = 0, // not supported in Tachidesk
                         updateStrategy = UpdateStrategy.valueOf(mangaRow[MangaTable.updateStrategy]),
+                        lastModifiedAt = mangaRow[MangaTable.lastModifiedAt],
+                        version = mangaRow[MangaTable.version],
                     )
 
                 val mangaId = mangaRow[MangaTable.id].value
@@ -110,6 +112,8 @@ object BackupMangaHandler {
                                     it.uploadDate,
                                     it.chapterNumber,
                                     chapters.size - it.index,
+                                    it.lastModifiedAt,
+                                    it.version,
                                 ).apply {
                                     if (flags.includeClientData) {
                                         this.meta = chapterToMeta[it.id] ?: emptyMap()
@@ -232,6 +236,9 @@ object BackupMangaHandler {
                                 it[inLibrary] = manga.favorite
 
                                 it[inLibraryAt] = manga.dateAdded.milliseconds.inWholeSeconds
+
+                                it[lastModifiedAt] = manga.lastModifiedAt
+                                it[version] = manga.version
                             }.value
                     } else {
                         val dbMangaId = dbManga[MangaTable.id].value
@@ -251,6 +258,9 @@ object BackupMangaHandler {
                             it[inLibrary] = manga.favorite || dbManga[inLibrary]
 
                             it[inLibraryAt] = manga.dateAdded.milliseconds.inWholeSeconds
+
+                            it[lastModifiedAt] = manga.lastModifiedAt
+                            it[version] = manga.version
                         }
 
                         dbMangaId
@@ -268,7 +278,7 @@ object BackupMangaHandler {
                     restoreMangaChapterData(mangaId, restoreMode, chapters, history, flags)
                 }
 
-                // merge categories
+                // update categories
                 if (flags.includeCategories) {
                     restoreMangaCategoryData(mangaId, categoryIds)
                 }
@@ -339,6 +349,9 @@ object BackupMangaHandler {
                             this[ChapterTable.lastReadAt] =
                                 historyByChapter[chapter.url]?.maxOrNull()?.milliseconds?.inWholeSeconds ?: 0
                         }
+
+                        this[ChapterTable.lastModifiedAt] = chapter.lastModifiedAt
+                        this[ChapterTable.version] = chapter.version
                     }.map { it[ChapterTable.id].value }
             } else {
                 emptyList()
@@ -387,6 +400,7 @@ object BackupMangaHandler {
         mangaId: Int,
         categoryIds: List<Int>,
     ) {
+        CategoryManga.removeMangaFromAllCategories(mangaId)
         CategoryManga.addMangaToCategories(mangaId, categoryIds)
     }
 

server/src/main/kotlin/suwayomi/tachidesk/manga/impl/backup/proto/models/BackupCategory.kt

@@ -10,6 +10,10 @@ class BackupCategory(
     // @ProtoNumber(3) val updateInterval: Int = 0, 1.x value not used in 0.x
     // Bump by 100 to specify this is a 0.x value
     @ProtoNumber(100) var flags: Int = 0,
+    // syncyomi
+    @ProtoNumber(601) var version: Long = 0,
+    @ProtoNumber(602) var uid: Long = 0,
+    @ProtoNumber(603) var lastModifiedAt: Long = 0,
     // suwayomi
     @ProtoNumber(9000) var meta: Map<String, String> = emptyMap(),
 )

server/src/main/kotlin/suwayomi/tachidesk/manga/impl/backup/proto/models/BackupChapter.kt

@@ -19,6 +19,9 @@ data class BackupChapter(
     // chapterNumber is called number is 1.x
     @ProtoNumber(9) var chapterNumber: Float = 0F,
     @ProtoNumber(10) var sourceOrder: Int = 0,
+    // syncyomi
+    @ProtoNumber(11) var lastModifiedAt: Long = 0,
+    @ProtoNumber(12) var version: Long = 0,
     // suwayomi
     @ProtoNumber(9000) var meta: Map<String, String> = emptyMap(),
 )

server/src/main/kotlin/suwayomi/tachidesk/manga/impl/backup/proto/models/BackupManga.kt

@@ -34,6 +34,9 @@ data class BackupManga(
     @ProtoNumber(103) var viewer_flags: Int? = null,
     @ProtoNumber(104) var history: List<BackupHistory> = emptyList(),
     @ProtoNumber(105) var updateStrategy: UpdateStrategy = UpdateStrategy.ALWAYS_UPDATE,
+    // syncyomi
+    @ProtoNumber(106) var lastModifiedAt: Long = 0,
+    @ProtoNumber(109) var version: Long = 0,
     // suwayomi
     @ProtoNumber(9000) var meta: Map<String, String> = emptyMap(),
 )

server/src/main/kotlin/suwayomi/tachidesk/manga/impl/extension/Extension.kt

@@ -358,6 +358,7 @@ object Extension {
                 } else {
                     ExtensionTable.update({ ExtensionTable.pkgName eq pkgName }) {
                         it[isInstalled] = false
+                        it[hasUpdate] = false
                     }
                 }
 

server/src/main/kotlin/suwayomi/tachidesk/manga/impl/update/Updater.kt

@@ -28,6 +28,7 @@ import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Semaphore
 import kotlinx.coroutines.sync.withPermit
+import suwayomi.tachidesk.global.impl.sync.SyncManager
 import suwayomi.tachidesk.manga.impl.Category
 import suwayomi.tachidesk.manga.impl.CategoryManga
 import suwayomi.tachidesk.manga.impl.Chapter
@@ -337,90 +338,98 @@ class Updater : IUpdater {
         clear: Boolean?,
         forceAll: Boolean,
     ) {
-        saveLastUpdateTimestamp()
-
-        if (clear == true) {
-            reset()
-        }
-
-        val includeInUpdateStatusToCategoryMap = categories.groupBy { it.includeInUpdate }
-        val excludedCategories = includeInUpdateStatusToCategoryMap[IncludeOrExclude.EXCLUDE].orEmpty()
-        val includedCategories = includeInUpdateStatusToCategoryMap[IncludeOrExclude.INCLUDE].orEmpty()
-        val unsetCategories = includeInUpdateStatusToCategoryMap[IncludeOrExclude.UNSET].orEmpty()
-        val categoriesToUpdate =
-            if (forceAll) {
-                categories
-            } else {
-                includedCategories.ifEmpty { unsetCategories }
-            }
-        val skippedCategories = categories.subtract(categoriesToUpdate.toSet()).toList()
-        val updateStatusCategories =
-            mapOf(
-                Pair(CategoryUpdateStatus.UPDATING, categoriesToUpdate),
-                Pair(CategoryUpdateStatus.SKIPPED, skippedCategories),
-            )
-
-        logger.debug { "Updating categories: '${categoriesToUpdate.joinToString("', '") { it.name }}'" }
-
-        val categoriesToUpdateMangas =
-            categoriesToUpdate
-                .flatMap { CategoryManga.getCategoryMangaList(it.id) }
-                .distinctBy { it.id }
-        val mangasToCategoriesMap = CategoryManga.getMangasCategories(categoriesToUpdateMangas.map { it.id })
-        val mangasToUpdate =
-            categoriesToUpdateMangas
-                .asSequence()
-                .filter { it.updateStrategy == UpdateStrategy.ALWAYS_UPDATE }
-                .filter {
-                    if (serverConfig.excludeUnreadChapters.value) {
-                        (it.unreadCount ?: 0L) == 0L
-                    } else {
-                        true
-                    }
-                }.filter {
-                    if (it.initialized && serverConfig.excludeNotStarted.value) {
-                        it.lastReadAt != null
-                    } else {
-                        true
-                    }
-                }.filter {
-                    if (serverConfig.excludeCompleted.value) {
-                        it.status != MangaStatus.COMPLETED.name
-                    } else {
-                        true
-                    }
-                }.filter { forceAll || !excludedCategories.any { category -> mangasToCategoriesMap[it.id]?.contains(category) == true } }
-                .toList()
-        val skippedMangas = categoriesToUpdateMangas.subtract(mangasToUpdate.toSet()).toList()
-
-        this.updateStatusCategories = updateStatusCategories
-        this.updateStatusSkippedMangas = skippedMangas
-
-        if (mangasToUpdate.isEmpty()) {
-            // In case no manga gets updated and no update job was running before, the client would never receive an info
-            // about its update request
-            scope.launch {
-                updateStatus(immediate = true)
-            }
-            return
-        }
-
         scope.launch {
-            updateStatus(
-                categoryUpdates =
-                    updateStatusCategories[CategoryUpdateStatus.UPDATING]
-                        ?.map {
-                            CategoryUpdateJob(it, CategoryUpdateStatus.UPDATING)
-                        }.orEmpty(),
-                mangaUpdates = mangasToUpdate.map { UpdateJob(it) },
-                isRunning = true,
+            SyncManager.ensureSync()
+
+            saveLastUpdateTimestamp()
+
+            if (clear == true) {
+                reset()
+            }
+
+            val includeInUpdateStatusToCategoryMap = categories.groupBy { it.includeInUpdate }
+            val excludedCategories = includeInUpdateStatusToCategoryMap[IncludeOrExclude.EXCLUDE].orEmpty()
+            val includedCategories = includeInUpdateStatusToCategoryMap[IncludeOrExclude.INCLUDE].orEmpty()
+            val unsetCategories = includeInUpdateStatusToCategoryMap[IncludeOrExclude.UNSET].orEmpty()
+            val categoriesToUpdate =
+                if (forceAll) {
+                    categories
+                } else {
+                    includedCategories.ifEmpty { unsetCategories }
+                }
+            val skippedCategories = categories.subtract(categoriesToUpdate.toSet()).toList()
+            val updateStatusCategories =
+                mapOf(
+                    Pair(CategoryUpdateStatus.UPDATING, categoriesToUpdate),
+                    Pair(CategoryUpdateStatus.SKIPPED, skippedCategories),
+                )
+
+            logger.debug { "Updating categories: '${categoriesToUpdate.joinToString("', '") { it.name }}'" }
+
+            val categoriesToUpdateMangas =
+                categoriesToUpdate
+                    .flatMap { CategoryManga.getCategoryMangaList(it.id) }
+                    .distinctBy { it.id }
+            val mangasToCategoriesMap = CategoryManga.getMangasCategories(categoriesToUpdateMangas.map { it.id })
+            val mangasToUpdate =
+                categoriesToUpdateMangas
+                    .asSequence()
+                    .filter { it.updateStrategy == UpdateStrategy.ALWAYS_UPDATE }
+                    .filter {
+                        if (serverConfig.excludeUnreadChapters.value) {
+                            (it.unreadCount ?: 0L) == 0L
+                        } else {
+                            true
+                        }
+                    }.filter {
+                        if (it.initialized && serverConfig.excludeNotStarted.value) {
+                            it.lastReadAt != null
+                        } else {
+                            true
+                        }
+                    }.filter {
+                        if (serverConfig.excludeCompleted.value) {
+                            it.status != MangaStatus.COMPLETED.name
+                        } else {
+                            true
+                        }
+                    }.filter {
+                        forceAll ||
+                            !excludedCategories.any { category ->
+                                mangasToCategoriesMap[it.id]?.contains(category) == true
+                            }
+                    }.toList()
+            val skippedMangas = categoriesToUpdateMangas.subtract(mangasToUpdate.toSet()).toList()
+
+            this@Updater.updateStatusCategories = updateStatusCategories
+            this@Updater.updateStatusSkippedMangas = skippedMangas
+
+            if (mangasToUpdate.isEmpty()) {
+                // In case no manga gets updated and no update job was running before, the client would never receive an info
+                // about its update request
+                scope.launch {
+                    updateStatus(immediate = true)
+                }
+                return@launch
+            }
+
+            scope.launch {
+                updateStatus(
+                    categoryUpdates =
+                        updateStatusCategories[CategoryUpdateStatus.UPDATING]
+                            ?.map {
+                                CategoryUpdateJob(it, CategoryUpdateStatus.UPDATING)
+                            }.orEmpty(),
+                    mangaUpdates = mangasToUpdate.map { UpdateJob(it) },
+                    isRunning = true,
+                )
+            }
+
+            addMangasToQueue(
+                mangasToUpdate
+                    .sortedWith(compareBy(String.CASE_INSENSITIVE_ORDER, MangaDataClass::title)),
             )
         }
-
-        addMangasToQueue(
-            mangasToUpdate
-                .sortedWith(compareBy(String.CASE_INSENSITIVE_ORDER, MangaDataClass::title)),
-        )
     }
 
     override fun addMangasToQueue(mangas: List<MangaDataClass>) {

server/src/main/kotlin/suwayomi/tachidesk/manga/impl/util/DirName.kt

@@ -24,14 +24,22 @@ private val applicationDirs: ApplicationDirs by injectLazy()
 
 private val logger = KotlinLogging.logger { }
 
+private fun getMangaDir(
+    title: String,
+    sourceName: String,
+): String {
+    val sourceDir = SafePath.buildValidFilename(sourceName)
+    val mangaDir = SafePath.buildValidFilename(title)
+
+    return "$sourceDir/$mangaDir"
+}
+
 private fun getMangaDir(mangaId: Int): String =
     transaction {
         val mangaEntry = MangaTable.selectAll().where { MangaTable.id eq mangaId }.first()
         val source = GetCatalogueSource.getCatalogueSourceOrStub(mangaEntry[MangaTable.sourceReference])
 
-        val sourceDir = SafePath.buildValidFilename(source.toString())
-        val mangaDir = SafePath.buildValidFilename(mangaEntry[MangaTable.title])
-        "$sourceDir/$mangaDir"
+        getMangaDir(mangaEntry[MangaTable.title], source.toString())
     }
 
 private fun getChapterDir(
@@ -62,8 +70,18 @@ private fun getChapterDir(
 
 fun getThumbnailDownloadPath(mangaId: Int): String = applicationDirs.thumbnailDownloadsRoot + "/$mangaId"
 
+fun getMangaDownloadDir(
+    title: String,
+    sourceName: String,
+): String = applicationDirs.mangaDownloadsRoot + "/" + getMangaDir(title, sourceName)
+
 fun getMangaDownloadDir(mangaId: Int): String = applicationDirs.mangaDownloadsRoot + "/" + getMangaDir(mangaId)
 
+fun getMangaCacheDir(
+    title: String,
+    sourceName: String,
+): String = applicationDirs.tempMangaCacheRoot + "/" + getMangaDir(title, sourceName)
+
 fun getChapterDownloadPath(
     mangaId: Int,
     chapterId: Int,
@@ -79,38 +97,21 @@ fun getChapterCachePath(
     chapterId: Int,
 ): String = applicationDirs.tempMangaCacheRoot + "/" + getChapterDir(mangaId, chapterId)
 
-/** return value says if rename/move was successful */
-fun updateMangaDownloadDir(
-    mangaId: Int,
-    newTitle: String,
+private fun updateDownloadDir(
+    currentDir: String,
+    newDir: String,
 ): Boolean {
-    // Get current manga directory (uses its own transaction)
-    val currentMangaDir = getMangaDir(mangaId)
-
-    // Build new directory path
-    val newMangaDir =
-        transaction {
-            val mangaEntry = MangaTable.selectAll().where { MangaTable.id eq mangaId }.first()
-            val source = GetCatalogueSource.getCatalogueSourceOrStub(mangaEntry[MangaTable.sourceReference])
-            val sourceDir = SafePath.buildValidFilename(source.toString())
-            val newMangaDirName = SafePath.buildValidFilename(newTitle)
-            "$sourceDir/$newMangaDirName"
-        }
-
-    val oldDir = "${applicationDirs.downloadsRoot}/$currentMangaDir"
-    val newDir = "${applicationDirs.downloadsRoot}/$newMangaDir"
-
-    val oldDirFile = File(oldDir)
+    val currentDirFile = File(currentDir)
     val newDirFile = File(newDir)
 
-    if (!oldDirFile.exists()) {
+    if (!currentDirFile.exists()) {
         return true
     }
 
     return try {
-        Files.move(oldDirFile.toPath(), newDirFile.toPath())
+        Files.move(currentDirFile.toPath(), newDirFile.toPath())
 
-        if (oldDirFile.exists()) {
+        if (currentDirFile.exists()) {
             return false
         }
 
@@ -118,9 +119,31 @@ fun updateMangaDownloadDir(
             return false
         }
 
-        true
+        return true
     } catch (e: Exception) {
-        logger.error(e) { "updateMangaDownloadDir: failed to rename manga download folder from \"$oldDir\" to \"$newDir\"" }
+        logger.error(e) { "updateDownloadDir: failed to rename download folder from \"$currentDir\" to \"$newDir\"" }
         false
     }
 }
+
+/** return value says if rename/move was successful */
+fun updateMangaDownloadDir(
+    title: String,
+    sourceName: String,
+    newTitle: String,
+): Boolean {
+    val currentDownloadDir = getMangaDownloadDir(title, sourceName)
+    val newDownloadDir = getMangaDownloadDir(newTitle, sourceName)
+
+    val renamed = updateDownloadDir(currentDownloadDir, newDownloadDir)
+
+    val tryToKeepCachedFilesUsable = renamed
+    if (tryToKeepCachedFilesUsable) {
+        val currentCacheDir = getMangaCacheDir(title, sourceName)
+        val newCacheDir = getMangaCacheDir(newTitle, sourceName)
+
+        updateDownloadDir(currentCacheDir, newCacheDir)
+    }
+
+    return renamed
+}

server/src/main/kotlin/suwayomi/tachidesk/manga/model/dataclass/CategoryDataClass.kt

@@ -30,5 +30,8 @@ data class CategoryDataClass(
     val size: Int,
     val includeInUpdate: IncludeOrExclude,
     val includeInDownload: IncludeOrExclude,
+    val version: Long,
+    val uid: Long,
+    val lastModifiedAt: Long,
     val meta: Map<String, String> = emptyMap(),
 )

server/src/main/kotlin/suwayomi/tachidesk/manga/model/dataclass/ChapterDataClass.kt

@@ -38,6 +38,8 @@ data class ChapterDataClass(
     val pageCount: Int = -1,
     /** total chapter count, used to calculate if there's a next and prev chapter */
     val chapterCount: Int? = null,
+    val lastModifiedAt: Long = 0,
+    val version: Long = 0,
     /** used to store client specific values */
     val meta: Map<String, String> = emptyMap(),
 ) {

server/src/main/kotlin/suwayomi/tachidesk/manga/model/dataclass/MangaDataClass.kt

@@ -43,6 +43,8 @@ data class MangaDataClass(
     val age: Long? = if (lastFetchedAt == null) 0 else Instant.now().epochSecond.minus(lastFetchedAt),
     val chaptersAge: Long? = if (chaptersLastFetchedAt == null) null else Instant.now().epochSecond.minus(chaptersLastFetchedAt),
     val trackers: List<MangaTrackerDataClass>? = null,
+    val lastModifiedAt: Long = 0,
+    val version: Long = 0,
 ) {
     override fun toString(): String = "\"$title\" (id= $id) (sourceId= $sourceId)"
 }

server/src/main/kotlin/suwayomi/tachidesk/manga/model/dataclass/PaginatedList.kt

@@ -7,12 +7,21 @@ package suwayomi.tachidesk.manga.model.dataclass
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
+import java.util.Objects
 import kotlin.math.min
 
 open class PaginatedList<T>(
     val page: List<T>,
     val hasNextPage: Boolean,
-)
+) {
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other !is PaginatedList<T>) return false
+        return page == other.page && hasNextPage == other.hasNextPage
+    }
+
+    override fun hashCode(): Int = Objects.hash(page, hasNextPage)
+}
 
 const val PAGINATION_FACTOR = 50
 

server/src/main/kotlin/suwayomi/tachidesk/manga/model/table/CategoryMetaTable.kt

@@ -15,7 +15,7 @@ import suwayomi.tachidesk.manga.model.table.CategoryMetaTable.ref
  * Metadata storage for clients, about Category with id == [ref].
  */
 object CategoryMetaTable : IntIdTable() {
-    val key = varchar("key", 256)
+    val key = varchar("meta_key", 256)
     val value = varchar("value", 4096)
     val ref = reference("category_ref", CategoryTable, ReferenceOption.CASCADE)
 }

server/src/main/kotlin/suwayomi/tachidesk/manga/model/table/CategoryTable.kt

@@ -19,6 +19,11 @@ object CategoryTable : IntIdTable() {
     val isDefault = bool("is_default").default(false)
     val includeInUpdate = integer("include_in_update").default(IncludeOrExclude.UNSET.value)
     val includeInDownload = integer("include_in_download").default(IncludeOrExclude.UNSET.value)
+
+    val version = long("version").default(0)
+    val uid = long("uid").default(0)
+    val lastModifiedAt = long("last_modified_at").default(0)
+    val isSyncing = bool("is_syncing").default(false)
 }
 
 fun CategoryTable.toDataClass(categoryEntry: ResultRow) =
@@ -30,5 +35,8 @@ fun CategoryTable.toDataClass(categoryEntry: ResultRow) =
         Category.getCategorySize(categoryEntry[id].value),
         IncludeOrExclude.fromValue(categoryEntry[includeInUpdate]),
         IncludeOrExclude.fromValue(categoryEntry[includeInDownload]),
+        categoryEntry[version],
+        categoryEntry[uid],
+        categoryEntry[lastModifiedAt],
         Category.getCategoryMetaMap(categoryEntry[id].value),
     )

server/src/main/kotlin/suwayomi/tachidesk/manga/model/table/ChapterMetaTable.kt

@@ -26,7 +26,7 @@ import suwayomi.tachidesk.manga.model.table.ChapterMetaTable.ref
  * }
  */
 object ChapterMetaTable : IntIdTable() {
-    val key = varchar("key", 256)
+    val key = varchar("meta_key", 256)
     val value = varchar("value", 4096)
     val ref = reference("chapter_ref", ChapterTable, ReferenceOption.CASCADE)
 }

server/src/main/kotlin/suwayomi/tachidesk/manga/model/table/ChapterTable.kt

@@ -42,6 +42,10 @@ object ChapterTable : IntIdTable() {
     val manga = reference("manga", MangaTable, ReferenceOption.CASCADE)
 
     val koreaderHash = varchar("koreader_hash", 32).nullable()
+
+    val lastModifiedAt = long("last_modified_at").default(0)
+    val version = long("version").default(0)
+    val isSyncing = bool("is_syncing").default(false)
 }
 
 fun ChapterTable.toDataClass(
@@ -83,4 +87,6 @@ fun ChapterTable.toDataClass(
         } else {
             emptyMap()
         },
+    lastModifiedAt = chapterEntry[lastModifiedAt],
+    version = chapterEntry[version],
 )

server/src/main/kotlin/suwayomi/tachidesk/manga/model/table/MangaMetaTable.kt

@@ -26,7 +26,7 @@ import suwayomi.tachidesk.manga.model.table.MangaMetaTable.ref
  * }
  */
 object MangaMetaTable : IntIdTable() {
-    val key = varchar("key", 256)
+    val key = varchar("meta_key", 256)
     val value = varchar("value", 4096)
     val ref = reference("manga_ref", MangaTable, ReferenceOption.CASCADE)
 }

server/src/main/kotlin/suwayomi/tachidesk/manga/model/table/MangaTable.kt

@@ -46,6 +46,10 @@ object MangaTable : IntIdTable() {
     val chaptersLastFetchedAt = long("chapters_last_fetched_at").default(0)
 
     val updateStrategy = varchar("update_strategy", 256).default(UpdateStrategy.ALWAYS_UPDATE.name)
+
+    val lastModifiedAt = long("last_modified_at").default(0)
+    val version = long("version").default(0)
+    val isSyncing = bool("is_syncing").default(false)
 }
 
 fun MangaTable.toDataClass(
@@ -76,6 +80,8 @@ fun MangaTable.toDataClass(
     lastFetchedAt = mangaEntry[lastFetchedAt],
     chaptersLastFetchedAt = mangaEntry[chaptersLastFetchedAt],
     updateStrategy = UpdateStrategy.valueOf(mangaEntry[updateStrategy]),
+    lastModifiedAt = mangaEntry[lastModifiedAt],
+    version = mangaEntry[version],
 )
 
 enum class MangaStatus(

server/src/main/kotlin/suwayomi/tachidesk/manga/model/table/SourceMetaTable.kt

@@ -14,7 +14,7 @@ import suwayomi.tachidesk.manga.model.table.SourceMetaTable.ref
  * Metadata storage for clients, about Source with id == [ref].
  */
 object SourceMetaTable : IntIdTable() {
-    val key = varchar("key", 256)
+    val key = varchar("meta_key", 256)
     val value = varchar("value", 4096)
     val ref = long("source_ref")
 }

server/src/main/kotlin/suwayomi/tachidesk/server/Migration.kt

@@ -5,6 +5,8 @@ import android.content.Context
 import io.github.oshai.kotlinlogging.KotlinLogging
 import suwayomi.tachidesk.manga.impl.update.IUpdater
 import suwayomi.tachidesk.server.database.H2Migration
+import suwayomi.tachidesk.server.util.ExitCode
+import suwayomi.tachidesk.server.util.shutdownApp
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
 import java.io.File
@@ -99,31 +101,35 @@ private val MIGRATIONS =
 
 fun runMigrations(applicationDirs: ApplicationDirs) {
     val logger = KotlinLogging.logger("Migration")
+    try {
+        val migrationPreferences =
+            Injekt
+                .get<Application>()
+                .getSharedPreferences(
+                    "migrations",
+                    Context.MODE_PRIVATE,
+                )
+        val version = migrationPreferences.getInt("version", 0)
 
-    val migrationPreferences =
-        Injekt
-            .get<Application>()
-            .getSharedPreferences(
-                "migrations",
-                Context.MODE_PRIVATE,
-            )
-    val version = migrationPreferences.getInt("version", 0)
+        logger.info { "Running migrations, previous version $version, target version ${MIGRATIONS.size}" }
 
-    logger.info { "Running migrations, previous version $version, target version ${MIGRATIONS.size}" }
+        MIGRATIONS.forEachIndexed { index, (migrationName, migrationFunction) ->
+            val migrationVersion = index + 1
 
-    MIGRATIONS.forEachIndexed { index, (migrationName, migrationFunction) ->
-        val migrationVersion = index + 1
+            val isMigrationRequired = version < migrationVersion
+            if (!isMigrationRequired) {
+                logger.info { "Skipping migration version $migrationVersion: $migrationName" }
+                return@forEachIndexed
+            }
 
-        val isMigrationRequired = version < migrationVersion
-        if (!isMigrationRequired) {
-            logger.info { "Skipping migration version $migrationVersion: $migrationName" }
-            return@forEachIndexed
+            logger.info { "Running migration version $migrationVersion: $migrationName" }
+
+            migrationFunction(applicationDirs)
+
+            migrationPreferences.edit().putInt("version", migrationVersion).apply()
         }
-
-        logger.info { "Running migration version $migrationVersion: $migrationName" }
-
-        migrationFunction(applicationDirs)
-
-        migrationPreferences.edit().putInt("version", migrationVersion).apply()
+    } catch (e: Exception) {
+        logger.error(e) { "Failed to run migrations" }
+        shutdownApp(ExitCode.MigrationsRunFailure)
     }
 }

server/src/main/kotlin/suwayomi/tachidesk/server/ServerSetup.kt

@@ -14,15 +14,13 @@ import com.typesafe.config.ConfigException
 import com.typesafe.config.ConfigRenderOptions
 import com.typesafe.config.ConfigValue
 import com.typesafe.config.parser.ConfigDocument
-import dev.datlag.kcef.KCEF
-import dev.datlag.kcef.KCEFBuilder.Settings.LogSeverity
 import eu.kanade.tachiyomi.App
 import eu.kanade.tachiyomi.createAppModule
 import eu.kanade.tachiyomi.network.NetworkHelper
 import eu.kanade.tachiyomi.source.local.LocalSource
 import io.github.config4k.toConfig
 import io.github.oshai.kotlinlogging.KotlinLogging
-import io.javalin.json.JavalinJackson
+import io.javalin.json.JavalinJackson3
 import io.javalin.json.JsonMapper
 import kotlinx.coroutines.DelicateCoroutinesApi
 import kotlinx.coroutines.GlobalScope
@@ -38,6 +36,7 @@ import org.koin.core.context.startKoin
 import org.koin.core.module.Module
 import org.koin.dsl.module
 import suwayomi.tachidesk.global.impl.KcefWebView.Companion.toCefCookie
+import suwayomi.tachidesk.global.impl.sync.SyncManager
 import suwayomi.tachidesk.graphql.types.DatabaseType
 import suwayomi.tachidesk.i18n.LocalizationHelper
 import suwayomi.tachidesk.manga.impl.backup.proto.ProtoBackupExport
@@ -49,6 +48,7 @@ import suwayomi.tachidesk.server.database.databaseUp
 import suwayomi.tachidesk.server.generated.BuildConfig
 import suwayomi.tachidesk.server.settings.SettingsRegistry
 import suwayomi.tachidesk.server.util.AppMutex.handleAppMutex
+import suwayomi.tachidesk.server.util.CEFManager
 import suwayomi.tachidesk.server.util.ConfigTypeRegistration
 import suwayomi.tachidesk.server.util.ExitCode
 import suwayomi.tachidesk.server.util.SystemTray
@@ -222,7 +222,7 @@ fun serverModule(applicationDirs: ApplicationDirs): Module =
     module {
         single { applicationDirs }
         single<IUpdater> { Updater() }
-        single<JsonMapper> { JavalinJackson() }
+        single<JsonMapper> { JavalinJackson3() }
     }
 
 @OptIn(DelicateCoroutinesApi::class)
@@ -366,6 +366,7 @@ fun applicationSetup() {
         }
     } catch (e: Exception) {
         logger.error(e) { "Exception while creating initial server.conf" }
+        shutdownApp(ExitCode.SetupConfFileFailed)
     }
 
     // copy local source icon
@@ -378,6 +379,7 @@ fun applicationSetup() {
         }
     } catch (e: Exception) {
         logger.error(e) { "Exception while copying Local source's icon" }
+        shutdownApp(ExitCode.LocalSourceIconCopyFailure)
     }
 
     // fixes #119 , ref:
@@ -395,7 +397,12 @@ fun applicationSetup() {
 
     databaseUp()
 
-    LocalSource.register()
+    try {
+        LocalSource.register()
+    } catch (e: Exception) {
+        logger.error(e) { "Failed to setup LocalSource" }
+        shutdownApp(ExitCode.LocalSourceSetupFailure)
+    }
 
     serverConfig.subscribeTo(
         combine<Any, DatabaseSettings>(
@@ -511,56 +518,10 @@ fun applicationSetup() {
     // start DownloadManager and restore + resume downloads
     DownloadManager.restoreAndResumeDownloads()
 
+    SyncManager.scheduleSyncTask()
+
+    // asynchronously initialize CEF
     GlobalScope.launch {
-        val logger = KotlinLogging.logger("KCEF")
-        KCEF.init(
-            builder = {
-                progress {
-                    var lastNum = -1
-                    onDownloading {
-                        val num = it.roundToInt()
-                        if (num > lastNum) {
-                            lastNum = num
-                            logger.info { "KCEF download progress: $num%" }
-                        }
-                    }
-                }
-                download { github() }
-                settings {
-                    windowlessRenderingEnabled = true
-                    cachePath = (Path(applicationDirs.dataRoot) / "cache/kcef").toString()
-                    logSeverity = if (serverConfig.debugLogsEnabled.value) LogSeverity.Verbose else LogSeverity.Default
-                }
-                appHandler(
-                    KCEF.AppHandler(
-                        arrayOf(
-                            "--disable-gpu",
-                            // #1486 needed to be able to render without a window
-                            "--off-screen-rendering-enabled",
-                            // #1489 since /dev/shm is restricted in docker (OOM)
-                            "--disable-dev-shm-usage",
-                            // #1723 support Widevine (incomplete)
-                            "--enable-widevine-cdm",
-                            // #1736 JCEF does implement stack guards properly
-                            "--change-stack-guard-on-fork=disable",
-                        ),
-                    ),
-                )
-
-                val kcefDir = Path(applicationDirs.dataRoot) / "bin/kcef"
-                kcefDir.createDirectories()
-                installDir(kcefDir.toFile())
-            },
-            onError = { it?.printStackTrace() },
-        )
+        CEFManager.init()
     }
-
-    Runtime.getRuntime().addShutdownHook(
-        thread(start = false) {
-            val logger = KotlinLogging.logger("KCEF")
-            logger.debug { "Shutting down KCEF" }
-            KCEF.disposeBlocking()
-            logger.debug { "KCEF shutdown complete" }
-        },
-    )
 }

server/src/main/kotlin/suwayomi/tachidesk/server/database/DBManager.kt

@@ -27,7 +27,6 @@ import suwayomi.tachidesk.server.util.ExitCode
 import suwayomi.tachidesk.server.util.shutdownApp
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
-import java.sql.SQLException
 import kotlin.time.Duration.Companion.minutes
 import kotlin.time.Duration.Companion.seconds
 
@@ -145,14 +144,15 @@ object DBManager {
 
 private val logger = KotlinLogging.logger {}
 
-fun databaseUp() {
+fun databaseUp(givenDb: Database? = null) {
     val db =
-        try {
-            DBManager.setupDatabase()
-        } catch (e: Exception) {
-            logger.error(e) { "Failed to setup Database" }
-            return
-        }
+        givenDb
+            ?: try {
+                DBManager.setupDatabase()
+            } catch (e: Exception) {
+                logger.error(e) { "Failed to setup Database" }
+                return
+            }
 
     logger.info {
         "Using ${db.vendor} database version ${db.version}"
@@ -184,10 +184,8 @@ fun databaseUp() {
         }
         val migrations = loadMigrationsFrom("suwayomi.tachidesk.server.database.migration", ServerConfig::class.java)
         runMigrations(migrations)
-    } catch (e: SQLException) {
+    } catch (e: Exception) {
         logger.error(e) { "Error up-to-database migration" }
-        if (System.getProperty("crashOnFailedMigration").toBoolean()) {
-            shutdownApp(ExitCode.DbMigrationFailure)
-        }
+        shutdownApp(ExitCode.DbMigrationFailure)
     }
 }

server/src/main/kotlin/suwayomi/tachidesk/server/database/H2Migration.kt

@@ -9,9 +9,12 @@ import java.net.URLClassLoader
 import java.nio.file.Path
 import kotlin.io.path.Path
 import kotlin.io.path.absolutePathString
+import kotlin.io.path.bufferedReader
+import kotlin.io.path.bufferedWriter
 import kotlin.io.path.copyTo
 import kotlin.io.path.createDirectories
 import kotlin.io.path.deleteExisting
+import kotlin.io.path.deleteIfExists
 import kotlin.io.path.div
 import kotlin.io.path.exists
 import kotlin.io.path.name
@@ -46,6 +49,10 @@ object H2Migration {
         }
 
         val script = Path("$dbBase.${h2Old.substringAfterLast('.')}.sql")
+        script.deleteIfExists()
+
+        val modifiedScript = Path("$dbBase.${h2Old.substringAfterLast('.')}.modified.sql")
+        modifiedScript.deleteIfExists()
 
         // Backup original database.
         val backup = Path("$dbBase.mv.db.${h2Old.substringAfterLast('.')}.backup")
@@ -72,19 +79,32 @@ object H2Migration {
             libsDir.resolve("h2-$h2New.bin"),
         )
 
+        // Delete attempted migration if failed previously
+        val newDatabase = Path(rootDir, "database.${h2New.substringAfterLast('.')}.mv.db")
+        newDatabase.deleteIfExists()
+
+        val modifiedNewDatabase = Path(rootDir, "database.${h2Old.substringAfterLast('.')}.modified.${h2New.substringAfterLast('.')}.mv.db")
+        modifiedNewDatabase.deleteIfExists()
+
         runMigrationTool(
             migrationJar = migrationJar,
             libsDir = libsDir,
             mvStore = mvStore,
             script = script,
+            modifiedScript = modifiedScript,
             h2Old = h2Old,
             h2New = h2New,
         )
 
         // Move database to proper path
-        val newDatabase = Path(rootDir, "database.${h2New.substringAfterLast('.')}.mv.db")
-        newDatabase.copyTo(mvStore, overwrite = true)
-        newDatabase.deleteExisting()
+        if (modifiedNewDatabase.exists()) {
+            modifiedNewDatabase.copyTo(mvStore, overwrite = true)
+            modifiedNewDatabase.deleteExisting()
+            newDatabase.deleteIfExists()
+        } else {
+            newDatabase.copyTo(mvStore, overwrite = true)
+            newDatabase.deleteExisting()
+        }
 
         logger.info { "H2 migration completed successfully." }
     }
@@ -123,6 +143,7 @@ object H2Migration {
         libsDir: Path,
         mvStore: Path,
         script: Path,
+        modifiedScript: Path,
         h2Old: String,
         h2New: String,
     ) {
@@ -136,32 +157,77 @@ object H2Migration {
             val main =
                 clazz.getMethod("main", Array<String>::class.java)
 
-            main.invoke(
-                null,
-                arrayOf(
-                    // h2 driver dir
-                    "-l",
-                    libsDir.absolutePathString(),
-                    // from version
-                    "-f",
-                    h2Old,
-                    // to version
-                    "-t",
-                    h2New,
-                    // user
-                    "-u",
-                    "",
-                    // password
-                    "-p",
-                    "",
-                    // database.mv.db
-                    "-d",
-                    mvStore.absolutePathString(),
-                    // database backup in SQL
-                    "-s",
-                    script.absolutePathString(),
-                ),
-            )
+            try {
+                main.invoke(
+                    null,
+                    arrayOf(
+                        // h2 driver dir
+                        "-l",
+                        libsDir.absolutePathString(),
+                        // from version
+                        "-f",
+                        h2Old,
+                        // to version
+                        "-t",
+                        h2New,
+                        // user
+                        "-u",
+                        "",
+                        // password
+                        "-p",
+                        "",
+                        // database.mv.db
+                        "-d",
+                        mvStore.absolutePathString(),
+                        // database backup in SQL
+                        "-s",
+                        script.absolutePathString(),
+                    ),
+                )
+            } catch (e: Exception) {
+                // Modify raw .sql file as needed for compatibility
+                if (e.stackTraceToString().contains("Unknown data type: \"DATETIME\"; SQL statement:") && script.exists()) {
+                    script.bufferedReader().use { reader ->
+                        modifiedScript.bufferedWriter().use { writer ->
+                            reader.forEachLine { line ->
+                                writer.write(
+                                    line.replace(
+                                        "    \"EXECUTED_AT\" DATETIME(9) NOT NULL",
+                                        "    \"EXECUTED_AT\" TIMESTAMP(9) NOT NULL",
+                                    ),
+                                )
+                                writer.newLine()
+                            }
+                        }
+                    }
+
+                    main.invoke(
+                        null,
+                        arrayOf(
+                            // h2 driver dir
+                            "-l",
+                            libsDir.absolutePathString(),
+                            // from version
+                            "-f",
+                            h2Old,
+                            // to version
+                            "-t",
+                            h2New,
+                            // user
+                            "-u",
+                            "",
+                            // password
+                            "-p",
+                            "",
+                            // database.mv.db
+                            "-d",
+                            modifiedScript.absolutePathString(),
+                        ),
+                    )
+                } else {
+                    throw e
+                }
+            }
         }
     }
 }

server/src/main/kotlin/suwayomi/tachidesk/server/database/migration/M0023_CategoryMetaRefFix.kt

@@ -10,17 +10,10 @@ package suwayomi.tachidesk.server.database.migration
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 import de.neonew.exposed.migrations.helpers.SQLMigration
-import org.jetbrains.exposed.v1.jdbc.transactions.TransactionManager
+import suwayomi.tachidesk.server.database.migration.helpers.toSqlName
 
 @Suppress("ClassName", "unused")
 class M0023_CategoryMetaRefFix : SQLMigration() {
-    fun String.toSqlName(): String =
-        TransactionManager.defaultDatabase!!.identifierManager.let {
-            it.quoteIfNecessary(
-                it.inProperCase(this),
-            )
-        }
-
     private val CategoryMetaTable by lazy { "CategoryMeta".toSqlName() }
     private val CategoryRefColumn by lazy { "category_ref".toSqlName() }
     private val CategoryTable by lazy { "Category".toSqlName() }

server/src/main/kotlin/suwayomi/tachidesk/server/database/migration/M0049_FixDuplicatedMetas.kt

@@ -8,6 +8,7 @@ package suwayomi.tachidesk.server.database.migration
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 import de.neonew.exposed.migrations.helpers.SQLMigration
+import suwayomi.tachidesk.server.database.migration.helpers.toSqlName
 
 @Suppress("ClassName", "unused")
 class M0049_FixDuplicatedMetas : SQLMigration() {
@@ -15,7 +16,7 @@ class M0049_FixDuplicatedMetas : SQLMigration() {
         table: String,
         refColumn: String? = null,
     ): String {
-        val groupBy = listOfNotNull(refColumn, "KEY").joinToString(", ")
+        val groupBy = listOfNotNull(refColumn, "KEY".toSqlName()).joinToString(", ")
 
         return """
             DELETE FROM $table
@@ -30,10 +31,11 @@ class M0049_FixDuplicatedMetas : SQLMigration() {
             """.trimIndent()
     }
 
-    override val sql: String =
+    override val sql: String by lazy {
         createMigrationForTable("CATEGORYMETA", "CATEGORY_REF") +
             createMigrationForTable("CHAPTERMETA", "CHAPTER_REF") +
             createMigrationForTable("GLOBALMETA") +
             createMigrationForTable("MANGAMETA", "MANGA_REF") +
             createMigrationForTable("SOURCEMETA", "SOURCE_REF")
+    }
 }

server/src/main/kotlin/suwayomi/tachidesk/server/database/migration/M0055_RenameMetaKeys.kt

@@ -0,0 +1,38 @@
+package suwayomi.tachidesk.server.database.migration
+
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import de.neonew.exposed.migrations.helpers.SQLMigration
+import suwayomi.tachidesk.graphql.types.DatabaseType
+import suwayomi.tachidesk.server.database.migration.helpers.toSqlName
+import suwayomi.tachidesk.server.serverConfig
+
+@Suppress("ClassName", "unused")
+class M0055_RenameMetaKeys : SQLMigration() {
+    fun postgresRename(table: String): String =
+        "ALTER TABLE $table " +
+            "RENAME COLUMN " + "KEY".toSqlName() + " TO META_KEY;"
+
+    fun h2Rename(table: String): String =
+        "ALTER TABLE $table " +
+            "ALTER COLUMN " + "KEY".toSqlName() + " RENAME TO META_KEY;"
+
+    fun createRenameMigration(table: String): String =
+        when (serverConfig.databaseType.value) {
+            DatabaseType.H2 -> h2Rename(table.toSqlName())
+            DatabaseType.POSTGRESQL -> postgresRename(table.toSqlName())
+        }
+
+    override val sql: String by lazy {
+        createRenameMigration("CATEGORYMETA") +
+            createRenameMigration("CHAPTERMETA") +
+            createRenameMigration("GLOBALMETA") +
+            createRenameMigration("MANGAMETA") +
+            createRenameMigration("SOURCEMETA")
+    }
+}

server/src/main/kotlin/suwayomi/tachidesk/server/database/migration/M0056_SyncYomi.kt

@@ -0,0 +1,224 @@
+package suwayomi.tachidesk.server.database.migration
+
+import de.neonew.exposed.migrations.helpers.SQLMigration
+import suwayomi.tachidesk.graphql.types.DatabaseType
+import suwayomi.tachidesk.server.serverConfig
+
+@Suppress("ClassName", "unused")
+class M0056_SyncYomi : SQLMigration() {
+    override val sql =
+        when (serverConfig.databaseType.value) {
+            DatabaseType.POSTGRESQL -> postgresQuery()
+            DatabaseType.H2 -> h2Query()
+        }
+
+    // language=postgresql
+    fun postgresQuery(): String =
+        """
+        ALTER TABLE manga ADD COLUMN version BIGINT NOT NULL DEFAULT 0;
+        ALTER TABLE manga ADD COLUMN is_syncing BOOLEAN NOT NULL DEFAULT FALSE;
+        ALTER TABLE manga ADD COLUMN last_modified_at BIGINT NOT NULL DEFAULT 0;
+
+        ALTER TABLE chapter ADD COLUMN version BIGINT NOT NULL DEFAULT 0;
+        ALTER TABLE chapter ADD COLUMN is_syncing BOOLEAN NOT NULL DEFAULT FALSE;
+        ALTER TABLE chapter ADD COLUMN last_modified_at BIGINT NOT NULL DEFAULT 0;
+
+        ALTER TABLE category ADD COLUMN version BIGINT NOT NULL DEFAULT 0;
+        ALTER TABLE category ADD COLUMN uid BIGINT NOT NULL DEFAULT 0;
+        ALTER TABLE category ADD COLUMN is_syncing BOOLEAN NOT NULL DEFAULT FALSE;
+        ALTER TABLE category ADD COLUMN last_modified_at BIGINT NOT NULL DEFAULT 0;
+
+
+        CREATE OR REPLACE FUNCTION update_manga_version()
+        RETURNS trigger AS $$
+        BEGIN
+            IF NOT NEW.is_syncing
+               AND ROW(NEW.url, NEW.description, NEW.in_library)
+                   IS DISTINCT FROM
+                   ROW(OLD.url, OLD.description, OLD.in_library)
+            THEN
+                NEW.version := OLD.version + 1;
+            END IF;
+
+            RETURN NEW;
+        END;
+        $$ LANGUAGE plpgsql;
+
+        CREATE TRIGGER update_manga_version
+        AFTER UPDATE ON manga
+        FOR EACH ROW
+        EXECUTE FUNCTION update_manga_version();
+
+
+        CREATE OR REPLACE FUNCTION update_chapter_and_manga_version()
+        RETURNS trigger AS $$
+        BEGIN
+            IF NOT NEW.is_syncing
+               AND ROW(NEW.read, NEW.bookmark, NEW.last_page_read)
+                   IS DISTINCT FROM
+                   ROW(OLD.read, OLD.bookmark, OLD.last_page_read)
+            THEN
+                NEW.version := OLD.version + 1;
+        
+                UPDATE manga SET version = version + 1 WHERE id = NEW.manga AND is_syncing = FALSE;
+            END IF;
+
+            RETURN NEW;
+        END;
+        $$ LANGUAGE plpgsql;
+
+        CREATE TRIGGER update_chapter_and_manga_version
+        AFTER UPDATE ON chapter
+        FOR EACH ROW
+        EXECUTE FUNCTION update_chapter_and_manga_version();
+
+
+        CREATE OR REPLACE FUNCTION update_manga_last_modified_at()
+        RETURNS trigger AS $$
+        BEGIN
+            NEW.last_modified_at := EXTRACT(EPOCH FROM NOW());
+            RETURN NEW;
+        END;
+        $$ LANGUAGE plpgsql;
+        
+        CREATE TRIGGER update_manga_last_modified_at
+        BEFORE UPDATE OR INSERT ON manga
+        FOR EACH ROW
+        EXECUTE FUNCTION update_manga_last_modified_at();
+        
+        
+        CREATE OR REPLACE FUNCTION update_chapter_last_modified_at()
+        RETURNS trigger AS $$
+        BEGIN
+            NEW.last_modified_at := EXTRACT(EPOCH FROM NOW());
+            RETURN NEW;
+        END;
+        $$ LANGUAGE plpgsql;
+        
+        CREATE TRIGGER update_chapter_last_modified_at
+        BEFORE UPDATE OR INSERT ON chapter
+        FOR EACH ROW
+        EXECUTE FUNCTION update_chapter_last_modified_at();
+
+
+        CREATE OR REPLACE FUNCTION insert_manga_category_update_version()
+        RETURNS trigger AS $$
+        BEGIN
+            UPDATE manga SET version = version + 1 WHERE id = NEW.manga AND is_syncing = FALSE;
+
+            RETURN NEW;
+        END;
+        $$ LANGUAGE plpgsql;
+
+        CREATE TRIGGER insert_manga_category_update_version
+        AFTER INSERT ON categorymanga
+        FOR EACH ROW
+        EXECUTE FUNCTION insert_manga_category_update_version();
+        
+
+        CREATE OR REPLACE FUNCTION insert_category_uid()
+        RETURNS trigger AS $$
+        BEGIN
+            IF NEW.uid = 0 THEN
+                NEW.uid := RANDOM(1, 9223372036854775807);
+            END IF;
+
+            IF NEW.last_modified_at = 0 THEN
+                NEW.last_modified_at := EXTRACT(EPOCH FROM NOW());
+            END IF;
+
+            RETURN NEW;
+        END;
+        $$ LANGUAGE plpgsql;
+        
+        CREATE TRIGGER insert_category_uid
+        BEFORE INSERT ON category
+        FOR EACH ROW
+        EXECUTE FUNCTION insert_category_uid();
+        
+        
+        CREATE OR REPLACE FUNCTION update_category_version()
+        RETURNS trigger AS $$
+        BEGIN
+            IF NOT NEW.is_syncing
+               AND ROW(NEW.name, NEW.sort_order)
+                   IS DISTINCT FROM
+                   ROW(OLD.name, OLD.sort_order)
+            THEN
+                NEW.version := NEW.version + 1;
+                NEW.last_modified_at := EXTRACT(EPOCH FROM NOW());
+            END IF;
+
+            RETURN NEW;
+        END;
+        $$ LANGUAGE plpgsql;
+        
+        CREATE TRIGGER update_category_version
+        BEFORE UPDATE ON category
+        FOR EACH ROW
+        EXECUTE FUNCTION update_category_version();
+        """.trimIndent()
+
+    // language=h2
+    fun h2Query() =
+        """
+        ALTER TABLE manga ADD COLUMN version BIGINT NOT NULL DEFAULT 0;
+        ALTER TABLE manga ADD COLUMN is_syncing BOOLEAN NOT NULL DEFAULT FALSE;
+        ALTER TABLE manga ADD COLUMN last_modified_at BIGINT NOT NULL DEFAULT 0;
+
+        ALTER TABLE chapter ADD COLUMN version BIGINT NOT NULL DEFAULT 0;
+        ALTER TABLE chapter ADD COLUMN is_syncing BOOLEAN NOT NULL DEFAULT FALSE;
+        ALTER TABLE chapter ADD COLUMN last_modified_at BIGINT NOT NULL DEFAULT 0;
+
+        ALTER TABLE category ADD COLUMN version BIGINT NOT NULL DEFAULT 0;
+        ALTER TABLE category ADD COLUMN uid BIGINT NOT NULL DEFAULT 0;
+        ALTER TABLE category ADD COLUMN is_syncing BOOLEAN NOT NULL DEFAULT FALSE;
+        ALTER TABLE category ADD COLUMN last_modified_at BIGINT NOT NULL DEFAULT 0;
+        
+
+        CREATE TRIGGER update_manga_version 
+        BEFORE UPDATE ON manga
+        FOR EACH ROW
+        CALL "suwayomi.tachidesk.server.database.trigger.UpdateMangaVersionTrigger";
+        
+        CREATE TRIGGER update_chapter_and_manga_version
+        BEFORE UPDATE ON chapter
+        FOR EACH ROW
+        CALL "suwayomi.tachidesk.server.database.trigger.UpdateChapterAndMangaVersionTrigger";
+        
+        CREATE TRIGGER update_manga_last_modified_at
+        BEFORE UPDATE ON manga
+        FOR EACH ROW
+        CALL "suwayomi.tachidesk.server.database.trigger.UpdateMangaLastModifiedAtTrigger";
+        
+        CREATE TRIGGER insert_manga_last_modified_at
+        BEFORE INSERT ON manga
+        FOR EACH ROW
+        CALL "suwayomi.tachidesk.server.database.trigger.UpdateMangaLastModifiedAtTrigger";
+        
+        CREATE TRIGGER update_chapter_last_modified_at
+        BEFORE UPDATE ON chapter
+        FOR EACH ROW
+        CALL "suwayomi.tachidesk.server.database.trigger.UpdateChapterLastModifiedAtTrigger";
+        
+        CREATE TRIGGER insert_chapter_last_modified_at
+        BEFORE INSERT ON chapter
+        FOR EACH ROW
+        CALL "suwayomi.tachidesk.server.database.trigger.UpdateChapterLastModifiedAtTrigger";
+        
+        CREATE TRIGGER insert_manga_category_update_version
+        AFTER INSERT ON categorymanga
+        FOR EACH ROW
+        CALL "suwayomi.tachidesk.server.database.trigger.InsertMangaCategoryUpdateVersionTrigger";
+        
+        CREATE TRIGGER insert_category_uid
+        BEFORE INSERT ON category
+        FOR EACH ROW
+        CALL "suwayomi.tachidesk.server.database.trigger.InsertCategoryUidTrigger";
+        
+        CREATE TRIGGER update_category_version
+        BEFORE UPDATE ON category
+        FOR EACH ROW
+        CALL "suwayomi.tachidesk.server.database.trigger.UpdateCategoryVersionTrigger";
+        """.trimIndent()
+}

server/src/main/kotlin/suwayomi/tachidesk/server/database/migration/helpers/RenameFieldMigration.kt

@@ -1,17 +1,9 @@
 package suwayomi.tachidesk.server.database.migration.helpers
 
 import de.neonew.exposed.migrations.helpers.SQLMigration
-import org.jetbrains.exposed.v1.jdbc.transactions.TransactionManager
 import suwayomi.tachidesk.graphql.types.DatabaseType
 import suwayomi.tachidesk.server.serverConfig
 
-fun String.toSqlName(): String =
-    TransactionManager.current().db.identifierManager.let {
-        it.quoteIfNecessary(
-            it.inProperCase(this),
-        )
-    }
-
 abstract class RenameFieldMigration(
     tableName: String,
     originalName: String,

server/src/main/kotlin/suwayomi/tachidesk/server/database/migration/helpers/ToSqlName.kt

@@ -0,0 +1,10 @@
+package suwayomi.tachidesk.server.database.migration.helpers
+
+import org.jetbrains.exposed.v1.jdbc.transactions.TransactionManager
+
+fun String.toSqlName(): String =
+    TransactionManager.current().db.identifierManager.let {
+        it.quoteIfNecessary(
+            it.inProperCase(this),
+        )
+    }

server/src/main/kotlin/suwayomi/tachidesk/server/database/trigger/SyncYomiTriggers.kt

@@ -0,0 +1,141 @@
+package suwayomi.tachidesk.server.database.trigger
+
+import org.h2.tools.TriggerAdapter
+import java.sql.Connection
+import java.sql.ResultSet
+import kotlin.random.Random
+import kotlin.time.Clock
+
+@Suppress("unused")
+class UpdateMangaVersionTrigger : TriggerAdapter() {
+    override fun fire(
+        conn: Connection,
+        oldRow: ResultSet,
+        newRow: ResultSet,
+    ) {
+        val isSyncing = newRow.getBoolean("is_syncing")
+        val hasChanged =
+            oldRow.getString("url") != newRow.getString("url") ||
+                oldRow.getString("description") != newRow.getString("description") ||
+                oldRow.getBoolean("in_library") != newRow.getBoolean("in_library")
+
+        if (!isSyncing && hasChanged) {
+            val currentVersion = newRow.getLong("version")
+            newRow.updateLong("version", currentVersion + 1)
+        }
+    }
+}
+
+@Suppress("unused")
+class UpdateChapterAndMangaVersionTrigger : TriggerAdapter() {
+    override fun fire(
+        conn: Connection,
+        oldRow: ResultSet,
+        newRow: ResultSet,
+    ) {
+        val isSyncing = newRow.getBoolean("is_syncing")
+        val hasChanged =
+            oldRow.getBoolean("read") != newRow.getBoolean("read") ||
+                oldRow.getBoolean("bookmark") != newRow.getBoolean("bookmark") ||
+                oldRow.getInt("last_page_read") != newRow.getInt("last_page_read")
+
+        if (!isSyncing && hasChanged) {
+            val currentVersion = newRow.getLong("version")
+            newRow.updateLong("version", currentVersion + 1)
+
+            val mangaId = newRow.getInt("manga")
+            conn
+                .prepareStatement(
+                    "UPDATE MANGA SET version = version + 1 WHERE id = ? AND NOT is_syncing",
+                ).use {
+                    it.setInt(1, mangaId)
+                    it.executeUpdate()
+                }
+        }
+    }
+}
+
+@Suppress("unused")
+class UpdateMangaLastModifiedAtTrigger : TriggerAdapter() {
+    override fun fire(
+        conn: Connection,
+        oldRow: ResultSet?,
+        newRow: ResultSet,
+    ) {
+        newRow.updateLong("last_modified_at", Clock.System.now().epochSeconds)
+    }
+}
+
+@Suppress("unused")
+class UpdateChapterLastModifiedAtTrigger : TriggerAdapter() {
+    override fun fire(
+        conn: Connection,
+        oldRow: ResultSet?,
+        newRow: ResultSet,
+    ) {
+        newRow.updateLong("last_modified_at", Clock.System.now().epochSeconds)
+    }
+}
+
+@Suppress("unused")
+class InsertMangaCategoryUpdateVersionTrigger : TriggerAdapter() {
+    override fun fire(
+        conn: Connection,
+        oldRow: ResultSet?,
+        newRow: ResultSet,
+    ) {
+        val mangaId = newRow.getInt("manga")
+
+        conn
+            .prepareStatement(
+                "UPDATE MANGA SET version = version + 1 WHERE id = ? AND NOT is_syncing",
+            ).use {
+                it.setInt(1, mangaId)
+                it.executeUpdate()
+            }
+    }
+}
+
+@Suppress("unused")
+class InsertCategoryUidTrigger : TriggerAdapter() {
+    override fun fire(
+        conn: Connection,
+        oldRow: ResultSet?,
+        newRow: ResultSet,
+    ) {
+        if (newRow.getLong("uid") == 0L) {
+            newRow.updateLong("uid", Random.nextLong(1, Long.MAX_VALUE))
+        }
+
+        if (newRow.getLong("last_modified_at") == 0L) {
+            newRow.updateLong(
+                "last_modified_at",
+                Clock.System.now().epochSeconds,
+            )
+        }
+    }
+}
+
+@Suppress("unused")
+class UpdateCategoryVersionTrigger : TriggerAdapter() {
+    override fun fire(
+        conn: Connection,
+        oldRow: ResultSet,
+        newRow: ResultSet,
+    ) {
+        val isSyncing = newRow.getBoolean("is_syncing")
+        val hasChanged =
+            oldRow.getString("name") != newRow.getString("name") ||
+                oldRow.getInt("sort_order") != newRow.getInt("sort_order")
+
+        if (!isSyncing && hasChanged) {
+            val currentVersion = newRow.getLong("version")
+            newRow.updateLong("version", currentVersion + 1)
+
+            newRow.updateLong(
+                "last_modified_at",
+                Clock.System.now().epochSeconds,
+            )
+        }
+    }
+}

server/src/main/kotlin/suwayomi/tachidesk/server/util/AppExit.kt

@@ -21,6 +21,10 @@ enum class ExitCode(
     WebUISetupFailure(3),
     ConfigMigrationMisconfiguredFailure(4),
     DbMigrationFailure(5),
+    SetupConfFileFailed(6),
+    LocalSourceIconCopyFailure(7),
+    LocalSourceSetupFailure(8),
+    MigrationsRunFailure(9),
 }
 
 fun shutdownApp(exitCode: ExitCode) {

server/src/main/kotlin/suwayomi/tachidesk/server/util/CEFManager.kt

@@ -0,0 +1,573 @@
+package suwayomi.tachidesk.server.util
+
+import android.text.format.Formatter
+import com.jetbrains.cef.JCefAppConfig
+import eu.kanade.tachiyomi.network.ProgressListener
+import eu.kanade.tachiyomi.network.awaitSuccess
+import eu.kanade.tachiyomi.network.newCachelessCallWithProgress
+import eu.kanade.tachiyomi.network.parseAs
+import io.github.oshai.kotlinlogging.KotlinLogging
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.subscribe
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+import org.apache.commons.compress.archivers.tar.TarArchiveInputStream
+import org.apache.commons.compress.compressors.gzip.GzipCompressorInputStream
+import org.cef.CefApp
+import org.cef.CefSettings.LogSeverity
+import org.cef.SystemBootstrap
+import suwayomi.tachidesk.server.ApplicationDirs
+import suwayomi.tachidesk.server.generated.BuildConfig
+import suwayomi.tachidesk.server.serverConfig
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import uy.kohesive.injekt.injectLazy
+import xyz.nulldev.androidcompat.webkit.CefHelper
+import java.io.BufferedOutputStream
+import java.io.IOException
+import java.nio.file.Files
+import java.nio.file.LinkOption
+import java.nio.file.Path
+import java.nio.file.StandardOpenOption
+import java.nio.file.attribute.PosixFilePermission
+import kotlin.concurrent.thread
+import kotlin.io.path.ExperimentalPathApi
+import kotlin.io.path.Path
+import kotlin.io.path.absolute
+import kotlin.io.path.absolutePathString
+import kotlin.io.path.createDirectories
+import kotlin.io.path.createTempDirectory
+import kotlin.io.path.deleteExisting
+import kotlin.io.path.deleteIfExists
+import kotlin.io.path.deleteRecursively
+import kotlin.io.path.div
+import kotlin.io.path.exists
+import kotlin.io.path.getPosixFilePermissions
+import kotlin.io.path.inputStream
+import kotlin.io.path.isRegularFile
+import kotlin.io.path.isSameFileAs
+import kotlin.io.path.isSymbolicLink
+import kotlin.io.path.listDirectoryEntries
+import kotlin.io.path.moveTo
+import kotlin.io.path.outputStream
+import kotlin.io.path.readLines
+import kotlin.io.path.readSymbolicLink
+import kotlin.io.path.readText
+import kotlin.io.path.setPosixFilePermissions
+import kotlin.io.path.writeText
+import kotlin.streams.asSequence
+
+private val logger = KotlinLogging.logger {}
+
+@OptIn(ExperimentalPathApi::class)
+object CEFManager {
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default + Dispatchers.IO)
+    private val applicationDirs by lazy { Injekt.get<ApplicationDirs>() }
+    private val cefDir by lazy { Path(applicationDirs.dataRoot) / "bin/kcef" }
+    private val releaseFile by lazy { cefDir / "release" }
+
+    fun init() =
+        scope.launch {
+            serverConfig.subscribeTo(serverConfig.kcefEnabled, CEFManager::initAsync, ignoreInitialValue = false)
+
+            Runtime.getRuntime().addShutdownHook(
+                thread(start = false) {
+                    CefHelper.cefApp.value.getOrNull()?.let {
+                        logger.debug { "Shutting down CEF" }
+                        it.dispose()
+                        logger.debug { "CEF shutdown complete" }
+                    }
+                },
+            )
+        }
+
+    private suspend fun initAsync(): Unit =
+        try {
+            CefHelper.cefApp.value = Result.success(null)
+
+            if (!serverConfig.kcefEnabled.value) {
+                throw CefException("CEF is disabled")
+            }
+
+            System.loadLibrary("jawt")
+
+            if (serverConfig.debugLogsEnabled.value) System.setProperty("jcef.log.verbose", "true")
+
+            if (!isInstallationValid(releaseFile)) {
+                downloadRelease(cefDir)
+
+                if (!isInstallationValid(releaseFile)) {
+                    throw CefException("Failed to provide a valid installation, this is a bug!")
+                }
+                logger.info { "Downloaded CEF successfully!" }
+            }
+
+            val app =
+                if (CefApp.getInstanceIfAny() == null) {
+                    val config =
+                        JCefAppConfig.getInstance(cefDir.toString(), false).apply {
+                            appArgsAsList.addAll(
+                                arrayOf(
+                                    "--disable-gpu",
+                                    // #1486 needed to be able to render without a window
+                                    "--off-screen-rendering-enabled",
+                                    // #1489 since /dev/shm is restricted in docker (OOM)
+                                    "--disable-dev-shm-usage",
+                                    // #1723 support Widevine (incomplete)
+                                    "--enable-widevine-cdm",
+                                    // #1736 JCEF does implement stack guards properly
+                                    "--change-stack-guard-on-fork=disable",
+                                ),
+                            )
+                            cefSettings.apply {
+                                windowless_rendering_enabled = true
+                                cache_path = (Path(applicationDirs.dataRoot) / "cache/kcef").absolutePathString()
+                                log_severity =
+                                    if (serverConfig.debugLogsEnabled.value) {
+                                        LogSeverity.LOGSEVERITY_VERBOSE
+                                    } else {
+                                        LogSeverity.LOGSEVERITY_DEFAULT
+                                    }
+                            }
+                        }
+                    logger.debug {
+                        "Attempting to initialize CEF: exe=${config.getServerExe()}, settings={${
+                            config.cefSettings.getDescription()
+                        }}, args=${config.getAppArgs().contentToString()}"
+                    }
+
+                    // this is essentially https://github.com/JetBrains/jcef/blob/5b93e5b916068316f1c8e7f8a59bf958d5ffd6e1/java/org/cef/CefApp.java#L777
+                    // we do this here because JCEF has no mechanism to tell us that initalization failed, they just record in an inaccessible future
+                    val os = Platform.current.os
+                    when {
+                        os.isLinux -> {
+                            config.getLoader().loadLibrary("cef")
+                        }
+
+                        os.isWindows -> {
+                            config.getLoader().loadLibrary("chrome_elf")
+                            config.getLoader().loadLibrary("libcef")
+                        }
+
+                        else -> {}
+                    }
+                    config.getLoader().loadLibrary("jcef")
+
+                    CefApp.setIsRemoteEnabled(config.isRemoteEnabled)
+                    SystemBootstrap.setLoader(config.getLoader())
+                    CefApp.startup(config.getAppArgs())
+
+                    CefApp.getInstance(config.getAppArgs(), config.cefSettings, config.getServerExe())
+                } else {
+                    logger.debug { "Getting existing app instance" }
+                    CefApp.getInstance()
+                }
+            CefHelper.cefApp.value = Result.success(app)
+            logger.debug { "CEF app created" }
+
+            CefHelper.waitForInit().first()
+            return
+        } catch (e: Throwable) {
+            logger.error(e) { "Failed to set up CEF" }
+            CefHelper.cefApp.value = Result.failure(e)
+        }
+
+    internal fun isInstallationValid(releaseFile: Path): Boolean {
+        if (!releaseFile.exists() || !releaseFile.isRegularFile()) return false
+        return try {
+            releaseFile
+                .readLines()
+                .firstNotNullOfOrNull {
+                    if (it.contains("JCEF_VERSION_DETAILED")) it.split("=").getOrNull(1) else null
+                }?.let {
+                    logger.debug { "Comparing internal ${BuildConfig.JCEF_VERSION} against downloaded $it" }
+                    BuildConfig.JCEF_VERSION.split("-chromium")[0] == it.split("-chromium")[0]
+                } ?: false
+        } catch (_: Exception) {
+            false
+        }
+    }
+
+    internal suspend fun downloadRelease(installDir: Path) {
+        logger.info { "Downloading CEF from Github (${BuildConfig.JCEF_JBR_RELEASE})" }
+        installDir.deleteRecursively()
+
+        if (!runCatching { installDir.createDirectories() }.isSuccess) {
+            throw CefException("Failed to create installation directory")
+        }
+
+        val client = OkHttpClient.Builder().followRedirects(true).build()
+        val request =
+            Request
+                .Builder()
+                .url("https://api.github.com/repos/JetBrains/JetBrainsRuntime/releases/tags/${BuildConfig.JCEF_JBR_RELEASE}")
+                .addHeader("Content-Type", GithubReleaseTransform.GITHUB_JSON)
+                .build()
+
+        val downloadUrl =
+            client.newCall(request).awaitSuccess().use { response ->
+                if (!response.isSuccessful) throw IOException("Unexpected code $response")
+                GithubReleaseTransform.transform(response)
+            }
+
+        val tempDownload = createTempDirectory("cef")
+        try {
+            val downFile = tempDownload / "download.tar.gz"
+            val downloadRequest =
+                Request
+                    .Builder()
+                    .url(downloadUrl)
+                    .build()
+
+            downFile.outputStream().use { output ->
+                client
+                    .newCachelessCallWithProgress(
+                        downloadRequest,
+                        object : ProgressListener {
+                            private var lastPercent = 0L
+
+                            override fun update(
+                                bytesRead: Long,
+                                contentLength: Long,
+                                done: Boolean,
+                            ) {
+                                val newPercent = (bytesRead * 100).floorDiv(contentLength)
+                                if (newPercent != lastPercent) {
+                                    logger.info { "Downloading $newPercent% of ${Formatter.formatFileSize(null, contentLength)}" }
+                                    lastPercent = newPercent
+                                }
+                            }
+                        },
+                    ).awaitSuccess()
+                    .use { response ->
+                        response.body.byteStream().use { input -> input.copyTo(output) }
+                    }
+            }
+
+            logger.debug { "Extracting CEF..." }
+            TarGzExtractor.extract(
+                installDir,
+                downFile,
+                4096,
+            )
+            TarGzExtractor.move(
+                installDir,
+            )
+        } finally {
+            tempDownload.deleteRecursively()
+        }
+    }
+
+    class CefException(
+        msg: String,
+    ) : Exception(msg)
+
+    // based on https://github.com/DatL4g/KCEF/blob/master/kcef/src/main/kotlin/dev/datlag/kcef/KCEFBuilder.kt
+    private object GithubReleaseTransform {
+        private val json: Json by injectLazy()
+        private val urlRegex = "(https?://|www.)[-a-zA-Z0-9+&@#/%?=~_|!:.;]*[-a-zA-Z0-9+&@#/%=~_|]".toRegex()
+        const val GITHUB_JSON = "application/vnd.github+json"
+
+        fun transform(initialResponse: Response): String {
+            val release = with(json) { initialResponse.parseAs<GitHubRelease>() }
+
+            val packageUrlList =
+                urlRegex
+                    .findAll(release.body)
+                    .toList()
+                    .map { it.value }
+                    .filterNot {
+                        it.isBlank() || it.endsWith(".checksum", true)
+                    }.filter {
+                        it.contains("jcef", true)
+                    }
+
+            val platform = Platform.current
+            val osPackageList =
+                packageUrlList
+                    .filter { url ->
+                        platform.os.values.any { os ->
+                            url.contains(os, true)
+                        }
+                    }.ifEmpty {
+                        release.assets
+                            .filter { asset ->
+                                platform.os.values.any { os ->
+                                    asset.name.contains(os, true) || asset.downloadUrl.contains(os, true)
+                                } && asset.downloadUrl.isNotBlank()
+                            }.filter { asset ->
+                                platform.arch.values.any { arch ->
+                                    asset.name.contains(arch, ignoreCase = true) ||
+                                        asset.downloadUrl.contains(
+                                            arch,
+                                            true,
+                                        )
+                                } && asset.downloadUrl.isNotBlank()
+                            }.map { it.downloadUrl }
+                    }
+            val platformPackageList =
+                osPackageList.filter { url ->
+                    platform.arch.values.any { arch ->
+                        url.contains(arch, true)
+                    }
+                }
+
+            if (platformPackageList.isEmpty()) {
+                throw CefException("Platform not supported by CEF (${platform.os},${platform.arch})")
+            }
+
+            val sortedPackageList =
+                platformPackageList.sortedWith(
+                    compareBy<String> {
+                        if (it.contains("sdk", true)) {
+                            1
+                        } else {
+                            0
+                        }
+                    }.thenBy {
+                        if (it.endsWith(".tar.gz", true)) {
+                            0
+                        } else {
+                            1
+                        }
+                    },
+                )
+
+            return sortedPackageList.first()
+        }
+
+        @Serializable
+        private data class GitHubRelease(
+            val body: String,
+            val assets: List<Asset> = emptyList(),
+        ) {
+            @Serializable
+            data class Asset(
+                val name: String = "",
+                @SerialName("browser_download_url") val downloadUrl: String = "",
+            )
+        }
+    }
+
+    // based on https://github.com/DatL4g/KCEF/blob/master/kcef/src/main/kotlin/dev/datlag/kcef/step/extract/TarGzExtractor.kt
+    internal data object TarGzExtractor {
+        internal fun Path.validate(parent: Path): Boolean =
+            runCatching {
+                this.normalize().startsWith(parent)
+            }.getOrNull() ?: false
+
+        internal fun Path.isSymlink(): Boolean =
+            runCatching {
+                this.isSymbolicLink()
+            }.getOrNull() ?: runCatching {
+                !this.isRegularFile(LinkOption.NOFOLLOW_LINKS)
+            }.getOrNull() ?: false
+
+        internal fun Path.getRealFile(): Path =
+            if (isSymlink()) {
+                runCatching {
+                    this.readSymbolicLink()
+                }.getOrNull() ?: this
+            } else {
+                this
+            }
+
+        internal fun Path.isSame(file: Path?): Boolean {
+            var sourceFile = this.getRealFile()
+            if (!sourceFile.exists()) {
+                sourceFile = this
+            }
+
+            var targetFile = file?.getRealFile() ?: file
+            if (targetFile?.exists() == false) {
+                targetFile = file
+            }
+
+            return if (targetFile == null) {
+                false
+            } else {
+                this == targetFile || runCatching {
+                    sourceFile.absolute() == targetFile.absolute() || sourceFile.isSameFileAs(targetFile)
+                }.getOrNull() ?: false
+            }
+        }
+
+        fun extract(
+            installDir: Path,
+            downloadedFile: Path,
+            bufferSize: Long,
+        ) {
+            downloadedFile.inputStream().use { `in` ->
+                GzipCompressorInputStream(`in`).use { gzipIn ->
+                    TarArchiveInputStream(gzipIn).use { tarIn ->
+                        while (tarIn.nextEntry != null) {
+                            val currentEntry = tarIn.currentEntry
+
+                            if (currentEntry != null) {
+                                val file = installDir / currentEntry.name
+                                if (!file.validate(installDir)) {
+                                    throw CefException("bad archive")
+                                }
+
+                                if (currentEntry.isDirectory) {
+                                    file.createDirectories()
+                                } else {
+                                    BufferedOutputStream(
+                                        file.outputStream(StandardOpenOption.CREATE_NEW, StandardOpenOption.WRITE),
+                                        bufferSize.toInt(),
+                                    ).use { dest ->
+                                        tarIn.copyTo(dest)
+                                    }
+                                }
+                                try {
+                                    file.setPosixFilePermissions(
+                                        file.getPosixFilePermissions() +
+                                            setOf(
+                                                PosixFilePermission.OWNER_EXECUTE,
+                                                PosixFilePermission.GROUP_EXECUTE,
+                                                PosixFilePermission.OTHERS_EXECUTE,
+                                            ),
+                                    )
+                                } catch (_: UnsupportedOperationException) {
+                                    // ignore
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            downloadedFile.deleteExisting()
+        }
+
+        fun move(installDir: Path) {
+            val releaseFile =
+                Files.walk(installDir).use { s ->
+                    s
+                        .filter(Files::isRegularFile)
+                        .asSequence()
+                        .firstOrNull { it.fileName?.toString() == "release" }
+                } ?: (installDir / "release")
+            val releaseFileContents = if (releaseFile.exists()) releaseFile.readText(Charsets.UTF_8) else ""
+
+            val os = Platform.current.os
+            when {
+                os.isLinux -> linuxMove(installDir)
+                os.isMacOSX -> macMove(installDir)
+                os.isWindows -> winMove(installDir)
+                else -> linuxMove(installDir)
+            }
+
+            (installDir / "release").writeText(releaseFileContents)
+        }
+
+        private fun linuxMove(installDir: Path) {
+            var foundDir: Path? = null
+            var foundParent: Path? = null
+
+            installDir.listDirectoryEntries().forEach { parent ->
+                if ((parent / "lib").exists()) {
+                    foundDir = parent / "lib"
+                    foundParent = parent
+                }
+            }
+
+            foundDir?.let {
+                val target = it.moveTo(installDir / "lib")
+                foundParent?.let { p ->
+                    p.deleteRecursively()
+                    p.deleteIfExists()
+                }
+
+                installDir.listDirectoryEntries().forEach { deleteCandidate ->
+                    if (!deleteCandidate.isSame(target)) {
+                        deleteCandidate.deleteRecursively()
+                    }
+                }
+
+                target.listDirectoryEntries().forEach { moveCandidate ->
+                    moveCandidate.moveTo(installDir / moveCandidate.fileName)
+                }
+
+                target.deleteExisting()
+            }
+        }
+
+        private fun macMove(installDir: Path) {
+            var foundDir: Path? = null
+            var foundParent: Path? = null
+
+            installDir.listDirectoryEntries().forEach { parent ->
+                if ((parent / "Contents").exists()) {
+                    foundDir = parent / "Contents"
+                    foundParent = parent
+                }
+            }
+
+            val target = (installDir / "lib").also { it.createDirectories() }
+            foundDir?.let { contents ->
+                (contents / "Home" / "lib").listDirectoryEntries().forEach { moveCandidate ->
+                    moveCandidate.moveTo(target / moveCandidate.fileName)
+                }
+
+                (contents / "Frameworks").moveTo(
+                    target / "Frameworks",
+                )
+
+                foundParent?.let { p ->
+                    p.deleteRecursively()
+                    p.deleteIfExists()
+                }
+
+                installDir.listDirectoryEntries().forEach { deleteCandidate ->
+                    if (!deleteCandidate.isSame(target)) {
+                        deleteCandidate.deleteRecursively()
+                    }
+                }
+
+                target.listDirectoryEntries().forEach { moveCandidate ->
+                    moveCandidate.moveTo(installDir / moveCandidate.fileName)
+                }
+
+                target.deleteExisting()
+            }
+        }
+
+        private fun winMove(installDir: Path) {
+            var foundDir: Path? = null
+
+            installDir.listDirectoryEntries().forEach { parent ->
+                if ((parent / "lib").exists()) {
+                    foundDir = parent
+                }
+            }
+
+            foundDir?.let {
+                val target = (it / "lib").moveTo(installDir / "lib")
+                (it / "bin").listDirectoryEntries().forEach { moveCandidate ->
+                    moveCandidate.moveTo(target / moveCandidate.fileName)
+                }
+
+                installDir.listDirectoryEntries().forEach { deleteCandidate ->
+                    if (!deleteCandidate.isSame(target)) {
+                        deleteCandidate.deleteRecursively()
+                    }
+                }
+
+                target.listDirectoryEntries().forEach { moveCandidate ->
+                    moveCandidate.moveTo(installDir / moveCandidate.fileName)
+                }
+
+                target.deleteExisting()
+            }
+        }
+    }
+}

server/src/main/kotlin/suwayomi/tachidesk/server/util/Platform.kt

@@ -0,0 +1,132 @@
+package suwayomi.tachidesk.server.util
+
+import java.util.Locale
+
+data class OSInfo(
+    val os: OS,
+    val arch: ARCH,
+)
+
+object Platform {
+    private val oses: List<OS.OSCreator> = listOf(OS.OSCreator.MACOSX(), OS.OSCreator.LINUX(), OS.OSCreator.WINDOWS())
+    private val archs: List<ARCH.ARCHCreator> =
+        listOf(ARCH.ARCHCreator.AMD64(), ARCH.ARCHCreator.I386(), ARCH.ARCHCreator.ARM64(), ARCH.ARCHCreator.ARM())
+
+    val current: OSInfo by lazy { getCurrentPlatform() }
+
+    private fun getCurrentPlatform(): OSInfo {
+        val osName = System.getProperty("os.name")
+        val archName = System.getProperty("os.arch")
+        val os = oses.firstNotNullOfOrNull { if (it.matches(osName)) it.create(osName) else null }
+        val arch = archs.firstNotNullOfOrNull { if (it.matches(archName)) it.create(archName) else null }
+        if (os == null || arch == null) {
+            throw UnsupportedOperationException("Unsupported platform tuple $osName,$archName")
+        }
+        return OSInfo(os, arch)
+    }
+}
+
+sealed class OS(
+    val name: String,
+    vararg val values: String,
+) {
+    internal abstract class OSCreator(
+        vararg val values: String,
+    ) {
+        abstract fun create(name: String): OS
+
+        fun matches(name: String): Boolean =
+            values.any { name.startsWith(it, true) } ||
+                values.contains(
+                    name.lowercase(
+                        Locale.ENGLISH,
+                    ),
+                )
+
+        class MACOSX : OSCreator("mac", "darwin", "osx") {
+            override fun create(name: String) = OS.MACOSX(name, *values)
+        }
+
+        class LINUX : OSCreator("linux") {
+            override fun create(name: String) = OS.LINUX(name, *values)
+        }
+
+        class WINDOWS : OSCreator("win", "windows") {
+            override fun create(name: String) = OS.WINDOWS(name, *values)
+        }
+    }
+
+    class MACOSX(
+        name: String,
+        vararg values: String,
+    ) : OS(name, *values)
+
+    class LINUX(
+        name: String,
+        vararg values: String,
+    ) : OS(name, *values)
+
+    class WINDOWS(
+        name: String,
+        vararg values: String,
+    ) : OS(name, *values)
+
+    val isLinux: Boolean get() = this is LINUX
+    val isMacOSX: Boolean get() = this is MACOSX
+    val isWindows: Boolean get() = this is WINDOWS
+}
+
+sealed class ARCH(
+    val name: String,
+    vararg val values: String,
+) {
+    internal abstract class ARCHCreator(
+        vararg val values: String,
+    ) {
+        abstract fun create(name: String): ARCH
+
+        fun matches(name: String): Boolean =
+            values.any { name.startsWith(it, true) } ||
+                values.contains(
+                    name.lowercase(
+                        Locale.ENGLISH,
+                    ),
+                )
+
+        class AMD64 : ARCHCreator("amd64", "x86_64", "x64") {
+            override fun create(name: String) = ARCH.AMD64(name, *values)
+        }
+
+        class I386 : ARCHCreator("x86", "i386", "i486", "i586", "i686", "i786") {
+            override fun create(name: String) = ARCH.I386(name, *values)
+        }
+
+        class ARM64 : ARCHCreator("arm64", "aarch64") {
+            override fun create(name: String) = ARCH.ARM64(name, *values)
+        }
+
+        class ARM : ARCHCreator("arm") {
+            override fun create(name: String) = ARCH.ARM(name, *values)
+        }
+    }
+
+    class AMD64(
+        arch: String,
+        vararg values: String,
+    ) : ARCH(arch, *values)
+
+    class I386(
+        arch: String,
+        vararg values: String,
+    ) : ARCH(arch, *values)
+
+    class ARM64(
+        arch: String,
+        vararg values: String,
+    ) : ARCH(arch, *values)
+
+    class ARM(
+        arch: String,
+        vararg values: String,
+    ) : ARCH(arch, *values)
+}

server/src/test/kotlin/masstest/CloudFlareTest.kt

@@ -1,17 +1,22 @@
 package masstest
 
+import android.os.Looper
 import eu.kanade.tachiyomi.source.online.HttpSource
 import io.github.oshai.kotlinlogging.KotlinLogging
 import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.test.runTest
+import org.junit.jupiter.api.AfterAll
 import org.junit.jupiter.api.BeforeAll
+import org.junit.jupiter.api.Disabled
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
+import org.koin.core.context.stopKoin
 import suwayomi.tachidesk.manga.impl.Source
 import suwayomi.tachidesk.manga.impl.extension.Extension
 import suwayomi.tachidesk.manga.impl.extension.ExtensionsList
 import suwayomi.tachidesk.manga.impl.util.source.GetCatalogueSource
 import suwayomi.tachidesk.server.applicationSetup
+import suwayomi.tachidesk.server.settings.SettingsRegistry
 import suwayomi.tachidesk.test.BASE_PATH
 import suwayomi.tachidesk.test.setLoggingEnabled
 import xyz.nulldev.ts.config.CONFIG_PREFIX
@@ -25,8 +30,11 @@ class CloudFlareTest {
     fun setup() {
         val dataRoot = File(BASE_PATH).absolutePath
         System.setProperty("$CONFIG_PREFIX.server.rootDir", dataRoot)
+        Looper.clearMainLooperForTest()
+        SettingsRegistry.clear()
         applicationSetup()
         setLoggingEnabled(false)
+        return
 
         runBlocking {
             val extensions = ExtensionsList.getExtensionList()
@@ -48,9 +56,15 @@ class CloudFlareTest {
         setLoggingEnabled(true)
     }
 
+    @AfterAll
+    fun teardown() {
+        stopKoin()
+    }
+
     private val logger = KotlinLogging.logger {}
 
     @Test
+    @Disabled
     fun `test nhentai browse`() =
         runTest {
             assert(nhentai.getPopularManga(1).mangas.isNotEmpty()) {

server/src/test/kotlin/masstest/TestExtensionCompatibility.kt

@@ -7,6 +7,7 @@ package masstest
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
+import android.os.Looper
 import eu.kanade.tachiyomi.source.model.SChapter
 import eu.kanade.tachiyomi.source.model.SManga
 import eu.kanade.tachiyomi.source.online.HttpSource
@@ -17,9 +18,11 @@ import kotlinx.coroutines.awaitAll
 import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.sync.Semaphore
 import kotlinx.coroutines.sync.withPermit
+import org.junit.jupiter.api.AfterAll
 import org.junit.jupiter.api.BeforeAll
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
+import org.koin.core.context.stopKoin
 import suwayomi.tachidesk.manga.impl.Source.getSourceList
 import suwayomi.tachidesk.manga.impl.extension.Extension.installExtension
 import suwayomi.tachidesk.manga.impl.extension.Extension.uninstallExtension
@@ -28,6 +31,7 @@ import suwayomi.tachidesk.manga.impl.extension.ExtensionsList.getExtensionList
 import suwayomi.tachidesk.manga.impl.util.source.GetCatalogueSource.getCatalogueSourceOrNull
 import suwayomi.tachidesk.manga.model.dataclass.ExtensionDataClass
 import suwayomi.tachidesk.server.applicationSetup
+import suwayomi.tachidesk.server.settings.SettingsRegistry
 import suwayomi.tachidesk.test.BASE_PATH
 import suwayomi.tachidesk.test.setLoggingEnabled
 import xyz.nulldev.ts.config.CONFIG_PREFIX
@@ -51,6 +55,8 @@ class TestExtensionCompatibility {
     fun setup() {
         val dataRoot = File(BASE_PATH).absolutePath
         System.setProperty("$CONFIG_PREFIX.server.rootDir", dataRoot)
+        Looper.clearMainLooperForTest()
+        SettingsRegistry.clear()
         applicationSetup()
         setLoggingEnabled(false)
 
@@ -72,12 +78,22 @@ class TestExtensionCompatibility {
                     }
                 }
             }
-            sources = getSourceList().map { getCatalogueSourceOrNull(it.id.toLong())!! as HttpSource }
+            sources =
+                getSourceList()
+                    .filter {
+                        // filter local source
+                        it.id.toLong() != 0L
+                    }.map { getCatalogueSourceOrNull(it.id.toLong())!! as HttpSource }
         }
         setLoggingEnabled(true)
         File("$BASE_PATH/sources.txt").writeText(sources.joinToString("\n") { "${it.name} - ${it.lang.uppercase()} - ${it.id}" })
     }
 
+    @AfterAll
+    fun teardown() {
+        stopKoin()
+    }
+
     @Test
     fun runTest() {
         runBlocking(Dispatchers.Default) {

server/src/test/kotlin/suwayomi/tachidesk/CefTest.kt

@@ -0,0 +1,42 @@
+package suwayomi.tachidesk
+
+import kotlinx.coroutines.test.runTest
+import kotlinx.serialization.json.Json
+import org.koin.core.context.startKoin
+import org.koin.core.context.stopKoin
+import org.koin.dsl.module
+import suwayomi.tachidesk.server.util.CEFManager
+import java.nio.file.Files
+import kotlin.io.path.ExperimentalPathApi
+import kotlin.io.path.deleteRecursively
+import kotlin.io.path.div
+import kotlin.test.Test
+import kotlin.test.assertTrue
+
+@OptIn(ExperimentalPathApi::class)
+class CefTest {
+    @Test
+    fun downloadedJbrIsValidForJcef() =
+        runTest {
+            val tempDownload = Files.createTempDirectory("kcef")
+            val module =
+                module {
+                    single {
+                        Json {
+                            ignoreUnknownKeys = true
+                            explicitNulls = false
+                        }
+                    }
+                }
+            startKoin {
+                modules(module)
+            }
+            try {
+                CEFManager.downloadRelease(tempDownload)
+                assertTrue { CEFManager.isInstallationValid(tempDownload / "release") }
+            } finally {
+                tempDownload.deleteRecursively()
+                stopKoin()
+            }
+        }
+}

server/src/test/kotlin/suwayomi/tachidesk/FlowTest.kt

@@ -0,0 +1,26 @@
+package suwayomi.tachidesk
+
+import graphql.Assert.assertTrue
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.test.runTest
+import suwayomi.tachidesk.server.subscribeTo
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import kotlin.test.Test
+
+class FlowTest {
+    @Test
+    fun subscribe() =
+        runTest {
+            (1..1000).forEach { _ ->
+                val testFlow = MutableStateFlow(value = 3)
+                testFlow.first()
+                val latch = CountDownLatch(1)
+                subscribeTo(testFlow, ignoreInitialValue = false) { _ ->
+                    latch.countDown()
+                }
+                assertTrue(latch.await(5, TimeUnit.SECONDS))
+            }
+        }
+}

server/src/test/kotlin/suwayomi/tachidesk/LooperTest.kt

@@ -0,0 +1,86 @@
+package suwayomi.tachidesk
+
+import android.os.Handler
+import android.os.Looper
+import android.os.Message
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNotEquals
+import kotlin.test.assertTrue
+import kotlin.text.StringBuilder
+
+class LooperThread : Thread() {
+    var mHandler: Handler? = null
+    val latch = CountDownLatch(1)
+
+    override fun run() {
+        Looper.prepare()
+        mHandler = Handler(Looper.myLooper()!!)
+        latch.countDown()
+        Looper.loop()
+    }
+}
+
+class LooperTest {
+    @Test
+    fun multiplePostWork() {
+        val thread = LooperThread()
+        thread.start()
+        val sb = StringBuilder()
+        val latch = CountDownLatch(1)
+        assertTrue(thread.latch.await(5, TimeUnit.SECONDS))
+
+        thread.mHandler!!.post {
+            Thread.sleep(100)
+            sb.append("a_b_c")
+        }
+        thread.mHandler!!.post {
+            Thread.sleep(100)
+            sb.append("_d_e_f")
+        }
+        thread.mHandler!!.post {
+            Thread.sleep(100)
+            sb.append("_g_h_i")
+            latch.countDown()
+        }
+
+        assertNotEquals("a_b_c_d_e_f_g_h_i", sb.toString())
+        assertTrue(latch.await(5, TimeUnit.SECONDS))
+
+        assertEquals("a_b_c_d_e_f_g_h_i", sb.toString())
+        thread.mHandler!!.looper.quit()
+        // thread.join()
+    }
+
+    @Test
+    fun loopTest() {
+        val thread = LooperThread()
+        thread.start()
+        val sb = StringBuilder()
+        val expected = StringBuilder()
+        val latch = CountDownLatch(1)
+        assertTrue(thread.latch.await(5, TimeUnit.SECONDS))
+        val n = 100
+
+        for (i in 0 until n) {
+            thread.mHandler!!.post {
+                Thread.sleep(10)
+                sb.append("$i")
+            }
+            expected.append("$i")
+        }
+
+        thread.mHandler!!.post {
+            latch.countDown()
+        }
+
+        assertNotEquals(expected.toString(), sb.toString())
+        assertTrue(latch.await(5, TimeUnit.SECONDS), "only got to $sb")
+
+        assertEquals(expected.toString(), sb.toString())
+        thread.mHandler!!.looper.quit()
+        // thread.join()
+    }
+}

server/src/test/kotlin/suwayomi/tachidesk/manga/controller/CategoryControllerTest.kt

@@ -18,19 +18,22 @@ import suwayomi.tachidesk.test.clearTables
 class CategoryControllerTest : ApplicationTest() {
     @Test
     fun categoryReorder() {
+        clearTables(
+            CategoryTable,
+        )
         Category.createCategory("foo")
         Category.createCategory("bar")
         val cats = Category.getCategoryList()
         val foo = cats.asSequence().filter { it.name == "foo" }.first()
         val bar = cats.asSequence().filter { it.name == "bar" }.first()
-        assertEquals(1, foo.order)
-        assertEquals(2, bar.order)
+        assertEquals(0, foo.order)
+        assertEquals(1, bar.order)
         Category.reorderCategory(1, 2)
         val catsReordered = Category.getCategoryList()
         val fooReordered = catsReordered.asSequence().filter { it.name == "foo" }.first()
         val barReordered = catsReordered.asSequence().filter { it.name == "bar" }.first()
-        assertEquals(2, fooReordered.order)
-        assertEquals(1, barReordered.order)
+        assertEquals(1, fooReordered.order)
+        assertEquals(0, barReordered.order)
     }
 
     @AfterEach

server/src/test/kotlin/suwayomi/tachidesk/manga/impl/CategoryMangaTest.kt

@@ -35,7 +35,7 @@ class CategoryMangaTest : ApplicationTest() {
             CategoryManga.getCategoryMangaList(DEFAULT_CATEGORY_ID)[0].unreadCount,
             "Manga should not have any unread chapters",
         )
-        createChapters(mangaId, 10, false)
+        createChapters(mangaId, 10, false, start = 11)
         assertEquals(
             10,
             CategoryManga.getCategoryMangaList(DEFAULT_CATEGORY_ID)[0].unreadCount,

server/src/test/kotlin/suwayomi/tachidesk/test/ApplicationTest.kt

@@ -12,9 +12,12 @@ import eu.kanade.tachiyomi.createAppModule
 import eu.kanade.tachiyomi.network.NetworkHelper
 import eu.kanade.tachiyomi.source.local.LocalSource
 import io.github.oshai.kotlinlogging.KotlinLogging
+import org.jetbrains.exposed.v1.core.DatabaseConfig
+import org.jetbrains.exposed.v1.core.ExperimentalKeywordApi
 import org.jetbrains.exposed.v1.jdbc.Database
 import org.junit.jupiter.api.BeforeAll
 import org.koin.core.context.startKoin
+import org.koin.core.context.stopKoin
 import suwayomi.tachidesk.server.ApplicationDirs
 import suwayomi.tachidesk.server.JavalinSetup
 import suwayomi.tachidesk.server.ServerConfig
@@ -22,7 +25,9 @@ import suwayomi.tachidesk.server.androidCompat
 import suwayomi.tachidesk.server.database.databaseUp
 import suwayomi.tachidesk.server.serverConfig
 import suwayomi.tachidesk.server.serverModule
+import suwayomi.tachidesk.server.settings.SettingsRegistry
 import suwayomi.tachidesk.server.util.AppMutex.handleAppMutex
+import suwayomi.tachidesk.server.util.ConfigTypeRegistration
 import suwayomi.tachidesk.server.util.SystemTray
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
@@ -55,6 +60,13 @@ open class ApplicationTest {
         private var initializedTheApp = false
 
         fun testingSetup() {
+            // register Tachidesk's config which is dubbed "ServerConfig"
+            SettingsRegistry.clear()
+            ConfigTypeRegistration.registerCustomTypes()
+            GlobalConfigManager.registerModule(
+                ServerConfig.register { GlobalConfigManager.config },
+            )
+
             // Application dirs
             val applicationDirs = ApplicationDirs()
 
@@ -72,13 +84,9 @@ open class ApplicationTest {
                 File(it).mkdirs()
             }
 
-            // register Tachidesk's config which is dubbed "ServerConfig"
-            GlobalConfigManager.registerModule(
-                ServerConfig.register { GlobalConfigManager.config },
-            )
-
             // initialize Koin modules
             val app = App()
+            stopKoin()
             startKoin {
                 modules(
                     createAppModule(app),
@@ -128,14 +136,14 @@ open class ApplicationTest {
             }
 
             // create system tray
-            if (serverConfig.systemTrayEnabled.value) {
-                try {
-                    SystemTray.create()
-                } catch (e: Throwable) {
-                    // cover both java.lang.Exception and java.lang.Error
-                    e.printStackTrace()
-                }
-            }
+            // if (serverConfig.systemTrayEnabled.value) {
+            //     try {
+            //         SystemTray.create()
+            //     } catch (e: Throwable) {
+            //         // cover both java.lang.Exception and java.lang.Error
+            //         e.printStackTrace()
+            //     }
+            // }
 
             // Disable jetty's logging
             System.setProperty("org.eclipse.jetty.util.log.announce", "false")
@@ -154,8 +162,16 @@ open class ApplicationTest {
             // fixes #119 , ref: https://github.com/Suwayomi/Suwayomi-Server/issues/119#issuecomment-894681292 , source Id calculation depends on String.lowercase()
             Locale.setDefault(Locale.ENGLISH)
 
+            val dbConfig =
+                DatabaseConfig {
+                    useNestedTransactions = true
+                    @OptIn(ExperimentalKeywordApi::class)
+                    preserveKeywordCasing = false
+                    defaultSchema = null
+                }
+
             // in-memory database, don't discard database between connections/transactions
-            val db = Database.connect("jdbc:h2:mem:test;DB_CLOSE_DELAY=-1;", "org.h2.Driver")
+            val db = Database.connect("jdbc:h2:mem:test;DB_CLOSE_DELAY=-1;", "org.h2.Driver", databaseConfig = dbConfig)
 
             databaseUp(db)
 

server/src/test/kotlin/suwayomi/tachidesk/test/TestUtils.kt

@@ -55,8 +55,9 @@ fun createChapters(
     mangaId: Int,
     amount: Int,
     read: Boolean,
+    start: Int = 1,
 ) {
-    val list = listOf((0 until amount)).flatten().map { 1 }
+    val list = listOf((0 until amount)).flatten().map { it + start }
     transaction {
         ChapterTable
             .batchInsert(list) {