Preparing v0.24.0

src/modules/coreFeatures/ModuleCheckRemoteSize.ts

@@ -0,0 +1,90 @@
+import { LOG_LEVEL_INFO, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/logger";
+import { AbstractModule } from "../AbstractModule.ts";
+import { sizeToHumanReadable } from "octagonal-wheels/number";
+import { delay } from "octagonal-wheels/promises";
+import type { ICoreModule } from "../ModuleTypes.ts";
+
+export class ModuleCheckRemoteSize extends AbstractModule implements ICoreModule {
+    async $allScanStat(): Promise<boolean> {
+        this._log(`Checking storage sizes`, LOG_LEVEL_VERBOSE);
+        if (this.settings.notifyThresholdOfRemoteStorageSize < 0) {
+            const message = `Now, Self-hosted LiveSync is able to check the remote storage size on the start-up.
+
+You can configure the threshold size for your remote storage. This will be different for your server.
+
+Please choose the threshold size as you like.
+
+- 0: Do not warn about storage size.
+  This is recommended if you have enough space on the remote storage especially you have self-hosted. And you can check the storage size and rebuild manually.
+- 800: Warn if the remote storage size exceeds 800MB.
+  This is recommended if you are using fly.io with 1GB limit or IBM Cloudant.
+- 2000: Warn if the remote storage size exceeds 2GB.
+
+And if your actual storage size exceeds the threshold after the setup, you may warned again. But do not worry, you can enlarge the threshold (or rebuild everything to reduce the size).
+`
+            const ANSWER_0 = "Do not warn";
+            const ANSWER_800 = "800MB";
+            const ANSWER_2000 = "2GB";
+
+            const ret = await this.core.confirm.confirmWithMessage("Remote storage size threshold", message, [ANSWER_0, ANSWER_800, ANSWER_2000], ANSWER_800, 40);
+            if (ret == ANSWER_0) {
+                this.settings.notifyThresholdOfRemoteStorageSize = 0;
+                await this.core.saveSettings();
+            } else if (ret == ANSWER_800) {
+                this.settings.notifyThresholdOfRemoteStorageSize = 800;
+                await this.core.saveSettings();
+            } else {
+                this.settings.notifyThresholdOfRemoteStorageSize = 2000;
+                await this.core.saveSettings();
+            }
+        }
+        if (this.settings.notifyThresholdOfRemoteStorageSize > 0) {
+            const remoteStat = await this.core.replicator?.getRemoteStatus(this.settings);
+            if (remoteStat) {
+                const estimatedSize = remoteStat.estimatedSize;
+                if (estimatedSize) {
+                    const maxSize = this.settings.notifyThresholdOfRemoteStorageSize * 1024 * 1024;
+                    if (estimatedSize > maxSize) {
+                        const message = `Remote storage size: ${sizeToHumanReadable(estimatedSize)}. It exceeds the configured value ${sizeToHumanReadable(maxSize)}.
+This may cause the storage to be full. You should enlarge the remote storage, or rebuild everything to reduce the size. \n
+**Note:** If you are new to Self-hosted LiveSync, you should enlarge the threshold. \n
+
+Self-hosted LiveSync will not release the storage automatically even if the file is deleted. This is why they need regular maintenance.\n
+
+If you have enough space on the remote storage, you can enlarge the threshold. Otherwise, you should rebuild everything.\n
+
+However, **Please make sure that all devices have been synchronised**. \n
+\n`;
+                        const newMax = ~~(estimatedSize / 1024 / 1024) + 100;
+                        const ANSWER_ENLARGE_LIMIT = `Enlarge to ${newMax}MB`;
+                        const ANSWER_REBUILD = "Rebuild now";
+                        const ANSWER_IGNORE = "Dismiss";
+                        const ret = await this.core.confirm.confirmWithMessage("Remote storage size exceeded", message, [ANSWER_ENLARGE_LIMIT, ANSWER_REBUILD, ANSWER_IGNORE,], ANSWER_IGNORE, 20);
+                        if (ret == ANSWER_REBUILD) {
+                            const ret = await this.core.confirm.askYesNoDialog("This may take a bit of a long time. Do you really want to rebuild everything now?", { defaultOption: "No" });
+                            if (ret == "yes") {
+                                this._log(`Receiving all from the server before rebuilding`, LOG_LEVEL_NOTICE);
+                                await this.core.$$replicateAllFromServer(true);
+                                await delay(3000);
+                                this._log(`Obsidian will be reloaded to rebuild everything.`, LOG_LEVEL_NOTICE);
+                                await this.core.rebuilder.scheduleRebuild();
+                            }
+                        } else if (ret == ANSWER_ENLARGE_LIMIT) {
+                            this.settings.notifyThresholdOfRemoteStorageSize = ~~(estimatedSize / 1024 / 1024) + 100;
+                            this._log(`Threshold has been enlarged to ${this.settings.notifyThresholdOfRemoteStorageSize}MB`, LOG_LEVEL_NOTICE);
+                            await this.core.saveSettings();
+                        } else {
+                            // Dismiss or Close the dialog
+                        }
+
+                        this._log(`Remote storage size: ${sizeToHumanReadable(estimatedSize)} exceeded ${sizeToHumanReadable(this.settings.notifyThresholdOfRemoteStorageSize * 1024 * 1024)} `, LOG_LEVEL_INFO);
+                    } else {
+                        this._log(`Remote storage size: ${sizeToHumanReadable(estimatedSize)}`, LOG_LEVEL_INFO);
+                    }
+                }
+            }
+        }
+        return true;
+    }
+
+}

src/modules/coreFeatures/ModuleConflictChecker.ts

@@ -0,0 +1,75 @@
+import { AbstractModule } from "../AbstractModule.ts";
+import { LOG_LEVEL_NOTICE, type FilePathWithPrefix } from "../../lib/src/common/types";
+import { QueueProcessor } from "octagonal-wheels/concurrency/processor";
+import { sendValue } from "octagonal-wheels/messagepassing/signal";
+import type { ICoreModule } from "../ModuleTypes.ts";
+
+export class ModuleConflictChecker extends AbstractModule implements ICoreModule {
+
+    async $$queueConflictCheckIfOpen(file: FilePathWithPrefix): Promise<void> {
+        const path = file;
+        if (this.settings.checkConflictOnlyOnOpen) {
+            const af = this.core.$$getActiveFilePath();
+            if (af && af != path) {
+                this._log(`${file} is conflicted, merging process has been postponed.`, LOG_LEVEL_NOTICE);
+                return;
+            }
+        }
+        await this.core.$$queueConflictCheck(path);
+    }
+
+    async $$queueConflictCheck(file: FilePathWithPrefix): Promise<void> {
+        const optionalConflictResult = await this.core.$anyGetOptionalConflictCheckMethod(file);
+        if (optionalConflictResult == true) {
+            // The conflict has been resolved by another process.
+            return;
+        } else if (optionalConflictResult === "newer") {
+            // The conflict should be resolved by the newer entry.
+            await this.core.$anyResolveConflictByNewest(file);
+        } else {
+            this.conflictCheckQueue.enqueue(file);
+        }
+    }
+
+    $$waitForAllConflictProcessed(): Promise<boolean> {
+        return this.conflictResolveQueue.waitForAllProcessed();
+    }
+
+    // TODO-> Move to ModuleConflictResolver?
+    conflictResolveQueue = new QueueProcessor(async (filenames: FilePathWithPrefix[]) => {
+        await this.core.$$resolveConflict(filenames[0]);
+    }, {
+        suspended: false,
+        batchSize: 1,
+        concurrentLimit: 1,
+        delay: 10,
+        keepResultUntilDownstreamConnected: false
+    }).replaceEnqueueProcessor((queue, newEntity) => {
+        const filename = newEntity;
+        sendValue("cancel-resolve-conflict:" + filename, true);
+        const newQueue = [...queue].filter(e => e != newEntity);
+        return [...newQueue, newEntity];
+    });
+
+
+    conflictCheckQueue = // First process - Check is the file actually need resolve -
+        new QueueProcessor((files: FilePathWithPrefix[]) => {
+            const filename = files[0];
+            // const file = await this.core.storageAccess.isExists(filename);
+            // if (!file) return [];
+            // if (!(file instanceof TFile)) return;
+            // if ((file instanceof TFolder)) return [];
+            // Check again?
+            return Promise.resolve([filename]);
+            // this.conflictResolveQueue.enqueueWithKey(filename, { filename, file });
+        }, {
+            suspended: false,
+            batchSize: 1,
+            concurrentLimit: 5,
+            delay: 10,
+            keepResultUntilDownstreamConnected: true,
+            pipeTo: this.conflictResolveQueue,
+            totalRemainingReactiveSource: this.core.conflictProcessQueueCount
+        });
+
+}

src/modules/coreFeatures/ModuleConflictResolver.ts

@@ -0,0 +1,141 @@
+import { serialized } from "octagonal-wheels/concurrency/lock";
+import { AbstractModule } from "../AbstractModule.ts";
+import { AUTO_MERGED, CANCELLED, LOG_LEVEL_INFO, LOG_LEVEL_NOTICE, MISSING_OR_ERROR, NOT_CONFLICTED, type diff_check_result, type FilePathWithPrefix } from "../../lib/src/common/types";
+import { compareMTime, displayRev, TARGET_IS_NEW } from "../../common/utils";
+import diff_match_patch from "diff-match-patch";
+import { stripAllPrefixes, isPlainText } from "../../lib/src/string_and_binary/path";
+import type { ICoreModule } from "../ModuleTypes.ts";
+
+export class ModuleConflictResolver extends AbstractModule implements ICoreModule {
+
+    async $$resolveConflictByDeletingRev(path: FilePathWithPrefix, deleteRevision: string, subTitle = ""): Promise<typeof MISSING_OR_ERROR | typeof AUTO_MERGED> {
+        const title = `Resolving ${subTitle ? `[${subTitle}]` : ""}:`;
+        if (!await this.core.fileHandler.deleteRevisionFromDB(path, deleteRevision)) {
+            this._log(`${title} Could not delete conflicted revision ${displayRev(deleteRevision)} of ${path}`, LOG_LEVEL_NOTICE);
+            return MISSING_OR_ERROR;
+        }
+        this._log(`${title} Conflicted revision deleted ${displayRev(deleteRevision)} ${path}`, LOG_LEVEL_INFO);
+        if ((await this.core.databaseFileAccess.getConflictedRevs(path)).length != 0) {
+            this._log(`${title} some conflicts are left in ${path}`, LOG_LEVEL_INFO);
+            return AUTO_MERGED;
+        }
+        // If no conflicts were found, write the resolved content to the storage.
+        if (!await this.core.fileHandler.dbToStorage(path, stripAllPrefixes(path), true)) {
+            this._log(`Could not write the resolved content to the storage: ${path}`, LOG_LEVEL_NOTICE);
+            return MISSING_OR_ERROR;
+        }
+        this._log(`${path} Has been merged automatically`, LOG_LEVEL_NOTICE);
+        return AUTO_MERGED;
+    }
+
+
+    async checkConflictAndPerformAutoMerge(path: FilePathWithPrefix): Promise<diff_check_result> {
+        //
+        const ret = await this.localDatabase.tryAutoMerge(path, !this.settings.disableMarkdownAutoMerge);
+        if ("ok" in ret) {
+            return ret.ok;
+        }
+
+        if ("result" in ret) {
+            const p = ret.result;
+            // Merged content is coming.
+            // 1. Store the merged content to the storage
+            if (!await this.core.databaseFileAccess.storeContent(path, p)) {
+                this._log(`Merged content cannot be stored:${path}`, LOG_LEVEL_NOTICE);
+                return MISSING_OR_ERROR;
+            }
+            // 2. As usual, delete the conflicted revision and if there are no conflicts, write the resolved content to the storage.
+            return await this.core.$$resolveConflictByDeletingRev(path, ret.conflictedRev, "Sensible");
+        }
+
+        const { rightRev, leftLeaf, rightLeaf } = ret;
+
+        // should be one or more conflicts;
+        if (leftLeaf == false) {
+            // what's going on..
+            this._log(`could not get current revisions:${path}`, LOG_LEVEL_NOTICE);
+            return MISSING_OR_ERROR;
+        }
+        if (rightLeaf == false) {
+            // Conflicted item could not load, delete this.
+            return await this.core.$$resolveConflictByDeletingRev(path, rightRev, "MISSING OLD REV");
+        }
+
+        const isSame = leftLeaf.data == rightLeaf.data && leftLeaf.deleted == rightLeaf.deleted;
+        const isBinary = !isPlainText(path);
+        const alwaysNewer = this.settings.resolveConflictsByNewerFile;
+        if (isSame || isBinary || alwaysNewer) {
+            const result = compareMTime(leftLeaf.mtime, rightLeaf.mtime)
+            let loser = leftLeaf;
+            // if (lMtime > rMtime) {
+            if (result != TARGET_IS_NEW) {
+                loser = rightLeaf;
+            }
+            const subTitle = [`${isSame ? "same" : ""}`, `${isBinary ? "binary" : ""}`, `${alwaysNewer ? "alwaysNewer" : ""}`].join(",");
+            return await this.core.$$resolveConflictByDeletingRev(path, loser.rev, subTitle);
+        }
+        // make diff.
+        const dmp = new diff_match_patch();
+        const diff = dmp.diff_main(leftLeaf.data, rightLeaf.data);
+        dmp.diff_cleanupSemantic(diff);
+        this._log(`conflict(s) found:${path}`);
+        return {
+            left: leftLeaf,
+            right: rightLeaf,
+            diff: diff,
+        };
+    }
+
+
+
+    async $$resolveConflict(filename: FilePathWithPrefix): Promise<void> {
+        // const filename = filenames[0];
+        return await serialized(`conflict-resolve:${filename}`, async () => {
+            const conflictCheckResult = await this.checkConflictAndPerformAutoMerge(filename);
+            if (conflictCheckResult === MISSING_OR_ERROR || conflictCheckResult === NOT_CONFLICTED || conflictCheckResult === CANCELLED) {
+                // nothing to do.
+                this._log(`conflict:Nothing to do:${filename}`);
+                return;
+            }
+            if (conflictCheckResult === AUTO_MERGED) {
+                //auto resolved, but need check again;
+                if (this.settings.syncAfterMerge && !this.core.suspended) {
+                    //Wait for the running replication, if not running replication, run it once.
+                    await this.core.$$waitForReplicationOnce();
+                }
+                this._log("conflict:Automatically merged, but we have to check it again");
+                await this.core.$$queueConflictCheck(filename);
+                return;
+            }
+            if (this.settings.showMergeDialogOnlyOnActive) {
+                const af = this.core.$$getActiveFilePath();
+                if (af && af != filename) {
+                    this._log(`${filename} is conflicted. Merging process has been postponed to the file have got opened.`, LOG_LEVEL_NOTICE);
+                    return;
+                }
+            }
+            this._log("conflict:Manual merge required!");
+            await this.core.$anyResolveConflictByUI(filename, conflictCheckResult);
+        });
+    }
+
+    async $anyResolveConflictByNewest(filename: FilePathWithPrefix): Promise<boolean> {
+        const revs = await this.core.databaseFileAccess.getConflictedRevs(filename);
+        if (revs.length == 0) {
+            return Promise.resolve(true);
+        }
+        const mTimeAndRev = (await Promise.all(revs.map(async (rev) => {
+            const leaf = await this.core.databaseFileAccess.fetchEntryMeta(filename, rev);
+            if (leaf == false) {
+                return [0, rev] as [number, string];
+            }
+            return [leaf.mtime, rev] as [number, string];
+        }))).sort((a, b) => b[0] - a[0]);
+        this._log(`Resolving conflict by newest: ${filename} (Newest: ${new Date(mTimeAndRev[0][0]).toLocaleString()}) (${mTimeAndRev.length} revisions exists)`);
+        for (let i = 1; i < mTimeAndRev.length; i++) {
+            this._log(`conflict: Deleting the older revision ${mTimeAndRev[i][1]} (${new Date(mTimeAndRev[i][0]).toLocaleString()}) of ${filename}`);
+            await this.core.$$resolveConflictByDeletingRev(filename, mTimeAndRev[i][1], "NEWEST");
+        }
+        return true;
+    }
+}

src/modules/coreFeatures/ModuleRedFlag.ts

@@ -0,0 +1,106 @@
+import { LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/logger";
+import { normalizePath } from "../../deps.ts";
+import { FLAGMD_REDFLAG, FLAGMD_REDFLAG2, FLAGMD_REDFLAG2_HR, FLAGMD_REDFLAG3, FLAGMD_REDFLAG3_HR } from "../../lib/src/common/types.ts";
+import { AbstractModule } from "../AbstractModule.ts";
+import type { ICoreModule } from "../ModuleTypes.ts";
+
+export class ModuleRedFlag extends AbstractModule implements ICoreModule {
+
+    async isFlagFileExist(path: string) {
+        const redflag = await this.core.storageAccess.isExists(normalizePath(path));
+        if (redflag) {
+            return true;
+        }
+        return false;
+    }
+
+    async deleteFlagFile(path: string) {
+        try {
+            const isFlagged = await this.core.storageAccess.isExists(normalizePath(path));
+            if (isFlagged) {
+                await this.core.storageAccess.delete(path, true);
+            }
+        } catch (ex) {
+            this._log(`Could not delete ${path}`);
+            this._log(ex, LOG_LEVEL_VERBOSE);
+        }
+    }
+
+    isRedFlagRaised = async () => await this.isFlagFileExist(FLAGMD_REDFLAG)
+    isRedFlag2Raised = async () => await this.isFlagFileExist(FLAGMD_REDFLAG2) || await this.isFlagFileExist(FLAGMD_REDFLAG2_HR)
+    isRedFlag3Raised = async () => await this.isFlagFileExist(FLAGMD_REDFLAG3) || await this.isFlagFileExist(FLAGMD_REDFLAG3_HR)
+
+    async deleteRedFlag2() {
+        await this.deleteFlagFile(FLAGMD_REDFLAG2);
+        await this.deleteFlagFile(FLAGMD_REDFLAG2_HR);
+    }
+
+    async deleteRedFlag3() {
+        await this.deleteFlagFile(FLAGMD_REDFLAG3);
+        await this.deleteFlagFile(FLAGMD_REDFLAG3_HR);
+    }
+    async $everyOnLayoutReady(): Promise<boolean> {
+        try {
+            const isRedFlagRaised = await this.isRedFlagRaised();
+            const isRedFlag2Raised = await this.isRedFlag2Raised();
+            const isRedFlag3Raised = await this.isRedFlag3Raised();
+
+            if (isRedFlagRaised || isRedFlag2Raised || isRedFlag3Raised) {
+                if (isRedFlag2Raised) {
+                    if (await this.core.confirm.askYesNoDialog("Rebuild everything has been scheduled! Are you sure to rebuild everything?", { defaultOption: "Yes", timeout: 0 }) !== "yes") {
+                        await this.deleteRedFlag2();
+                        await this.core.$$performRestart();
+                        return false;
+                    }
+                }
+                if (isRedFlag3Raised) {
+                    if (await this.core.confirm.askYesNoDialog("Fetch again has been scheduled! Are you sure?", { defaultOption: "Yes", timeout: 0 }) !== "yes") {
+                        await this.deleteRedFlag3();
+                        await this.core.$$performRestart();
+                        return false;
+                    }
+                }
+                this.settings.batchSave = false;
+                await this.core.$allSuspendAllSync();
+                await this.core.$allSuspendExtraSync();
+                this.settings.suspendFileWatching = true;
+                await this.saveSettings();
+                if (isRedFlag2Raised) {
+                    this._log(`${FLAGMD_REDFLAG2} or ${FLAGMD_REDFLAG2_HR} has been detected! Self-hosted LiveSync suspends all sync and rebuild everything.`, LOG_LEVEL_NOTICE);
+                    await this.core.rebuilder.$rebuildEverything();
+                    await this.deleteRedFlag2();
+                    if (await this.core.confirm.askYesNoDialog("Do you want to resume file and database processing, and restart obsidian now?", { defaultOption: "Yes", timeout: 15 }) == "yes") {
+                        this.settings.suspendFileWatching = false;
+                        await this.saveSettings();
+                        this.core.$$performRestart();
+                        return false;
+                    }
+                } else if (isRedFlag3Raised) {
+                    this._log(`${FLAGMD_REDFLAG3} or ${FLAGMD_REDFLAG3_HR} has been detected! Self-hosted LiveSync will discard the local database and fetch everything from the remote once again.`, LOG_LEVEL_NOTICE);
+                    const makeLocalChunkBeforeSync = ((await this.core.confirm.askYesNoDialog("Do you want to create local chunks before fetching?", { defaultOption: "Yes" })) == "yes");
+                    await this.core.rebuilder.$fetchLocal(makeLocalChunkBeforeSync);
+                    await this.deleteRedFlag3();
+                    if (this.settings.suspendFileWatching) {
+                        if (await this.core.confirm.askYesNoDialog("Do you want to resume file and database processing, and restart obsidian now?", { defaultOption: "Yes", timeout: 15 }) == "yes") {
+                            this.settings.suspendFileWatching = false;
+                            await this.saveSettings();
+                            this.core.$$performRestart();
+                            return false;
+                        }
+                    }
+                } else {
+                    // Case of FLAGMD_REDFLAG.
+                    this.settings.writeLogToTheFile = true;
+                    // await this.plugin.openDatabase();
+                    const warningMessage = "The red flag is raised! The whole initialize steps are skipped, and any file changes are not captured.";
+                    this._log(warningMessage, LOG_LEVEL_NOTICE);
+                }
+            }
+        } catch (ex) {
+            this._log("Something went wrong on FlagFile Handling", LOG_LEVEL_NOTICE);
+            this._log(ex, LOG_LEVEL_VERBOSE);
+        }
+        return true;
+    }
+
+}

src/modules/coreFeatures/ModuleRemoteGovernor.ts

@@ -0,0 +1,16 @@
+import { AbstractModule } from "../AbstractModule.ts";
+import type { ICoreModule } from "../ModuleTypes.ts";
+
+export class ModuleRemoteGovernor extends AbstractModule implements ICoreModule {
+    async $$markRemoteLocked(lockByClean: boolean = false): Promise<void> {
+        return await this.core.replicator.markRemoteLocked(this.settings, true, lockByClean);
+    }
+
+    async $$markRemoteUnlocked(): Promise<void> {
+        return await this.core.replicator.markRemoteLocked(this.settings, false, false);
+    }
+
+    async $$markRemoteResolved(): Promise<void> {
+        return await this.core.replicator.markRemoteResolved(this.settings);
+    }
+}

src/modules/coreFeatures/ModuleResolveMismatchedTweaks.ts

@@ -0,0 +1,97 @@
+import { Logger, LOG_LEVEL_NOTICE } from "octagonal-wheels/common/logger";
+import { extractObject } from "octagonal-wheels/object";
+import { TweakValuesShouldMatchedTemplate, CompatibilityBreakingTweakValues, confName, type TweakValues } from "../../lib/src/common/types.ts";
+import { escapeMarkdownValue } from "../../lib/src/common/utils.ts";
+import { AbstractModule } from "../AbstractModule.ts";
+import type { ICoreModule } from "../ModuleTypes.ts";
+
+export class ModuleResolvingMismatchedTweaks extends AbstractModule implements ICoreModule {
+    async $anyAfterConnectCheckFailed(): Promise<boolean | "CHECKAGAIN" | undefined> {
+        if (!this.core.replicator.tweakSettingsMismatched) return false;
+        const ret = await this.core.$$askResolvingMismatchedTweaks();
+        if (ret == "OK") return false;
+        if (ret == "CHECKAGAIN") return "CHECKAGAIN";
+        if (ret == "IGNORE") return true;
+    }
+
+    async $$askResolvingMismatchedTweaks(): Promise<"OK" | "CHECKAGAIN" | "IGNORE"> {
+        if (!this.core.replicator.tweakSettingsMismatched) {
+            return "OK";
+        }
+        const preferred = extractObject(TweakValuesShouldMatchedTemplate, this.core.replicator.preferredTweakValue!);
+        const mine = extractObject(TweakValuesShouldMatchedTemplate, this.settings);
+        const items = Object.entries(TweakValuesShouldMatchedTemplate);
+        let rebuildRequired = false;
+
+        // Making tables:
+        let table = `| Value name | This device | Configured | \n` + `|: --- |: --- :|: ---- :| \n`;
+
+        // const items = [mine,preferred]
+        for (const v of items) {
+            const key = v[0] as keyof typeof TweakValuesShouldMatchedTemplate;
+            const valueMine = escapeMarkdownValue(mine[key]);
+            const valuePreferred = escapeMarkdownValue(preferred[key]);
+            if (valueMine == valuePreferred) continue;
+            if (CompatibilityBreakingTweakValues.indexOf(key) !== -1) {
+                rebuildRequired = true;
+            }
+            table += `| ${confName(key)} | ${valueMine} | ${valuePreferred} | \n`;
+        }
+
+        const additionalMessage = rebuildRequired ? `
+
+**Note**: We have detected that some of the values are different to make incompatible the local database with the remote database.
+If you choose to use the configured values, the local database will be rebuilt, and if you choose to use the values of this device, the remote database will be rebuilt. 
+Both of them takes a few minutes. Please choose after considering the situation.` : "";
+
+        const message = `
+Your configuration has not been matched with the one on the remote server.
+(Which you had decided once before, or set by initially synchronised device).
+
+Configured values:
+
+${table}
+
+Please select which one you want to use.
+
+- Use configured: Update settings of this device by configured one on the remote server.
+  You should select this if you have changed the settings on ** another device **.
+- Update with mine: Update settings on the remote server by the settings of this device.
+  You should select this if you have changed the settings on ** this device **.
+- Dismiss: Ignore this message and keep the current settings.
+  You cannot synchronise until you resolve this issue without enabling \`Do not check configuration mismatch before replication\`.${additionalMessage}`;
+
+        const CHOICE_USE_REMOTE = "Use configured";
+        const CHOICE_USR_MINE = "Update with mine";
+        const CHOICE_DISMISS = "Dismiss";
+        const CHOICE_AND_VALUES = [
+            [CHOICE_USE_REMOTE, preferred],
+            [CHOICE_USR_MINE, true],
+            [CHOICE_DISMISS, false]]
+        const CHOICES = Object.fromEntries(CHOICE_AND_VALUES) as Record<string, TweakValues | boolean>;
+        const retKey = await this.core.confirm.confirmWithMessage("Tweaks Mismatched or Changed", message, Object.keys(CHOICES), CHOICE_DISMISS, 60);
+        if (!retKey) return "IGNORE";
+        const conf = CHOICES[retKey];
+
+        if (conf === true) {
+            await this.core.replicator.setPreferredRemoteTweakSettings(this.settings);
+            if (rebuildRequired) {
+                await this.core.rebuilder.$rebuildRemote();
+            }
+            Logger(`Tweak values on the remote server have been updated. Your other device will see this message.`, LOG_LEVEL_NOTICE);
+            return "CHECKAGAIN";
+        }
+        if (conf) {
+            this.settings = { ...this.settings, ...conf };
+            await this.core.replicator.setPreferredRemoteTweakSettings(this.settings);
+            await this.core.$$saveSettingData();
+            if (rebuildRequired) {
+                await this.core.rebuilder.$fetchLocal();
+            }
+            Logger(`Configuration has been updated as configured by the other device.`, LOG_LEVEL_NOTICE);
+            return "CHECKAGAIN";
+        }
+        return "IGNORE";
+
+    }
+}