bump

- The setting pane refined.
- We can enable `hidden files sync` with several initial behaviours: `Merge`, `Fetch` remote, and `Overwrite` remote.
- No longer `Touch hidden files`

.eslintrc

@@ -1,19 +1,34 @@
 {
     "root": true,
     "parser": "@typescript-eslint/parser",
-    "plugins": ["@typescript-eslint"],
-    "extends": ["eslint:recommended", "plugin:@typescript-eslint/eslint-recommended", "plugin:@typescript-eslint/recommended"],
+    "plugins": [
+        "@typescript-eslint"
+    ],
+    "extends": [
+        "eslint:recommended",
+        "plugin:@typescript-eslint/eslint-recommended",
+        "plugin:@typescript-eslint/recommended"
+    ],
     "parserOptions": {
-        "sourceType": "module"
+        "sourceType": "module",
+        "project": [
+            "tsconfig.json"
+        ]
     },
     "rules": {
         "no-unused-vars": "off",
-        "@typescript-eslint/no-unused-vars": ["error", { "args": "none" }],
+        "@typescript-eslint/no-unused-vars": [
+            "error",
+            {
+                "args": "none"
+            }
+        ],
         "@typescript-eslint/ban-ts-comment": "off",
         "no-prototype-builtins": "off",
         "@typescript-eslint/no-empty-function": "off",
         "require-await": "warn",
         "no-async-promise-executor": "off",
-        "@typescript-eslint/no-explicit-any": "off"
+        "@typescript-eslint/no-explicit-any": "off",
+        "@typescript-eslint/no-unnecessary-type-assertion": "error"
     }
-}
+}

README.md

@@ -56,7 +56,8 @@ If you answered `No` to both, your databases will be rebuilt by the content on y
 
 ## Test Server
 
-Setting up an instance of Cloudant or local CouchDB is a little complicated, so I set up a [Tasting server for self-hosted-livesync](https://olstaste.vrtmrz.net/). Try it out for free!  
+~~Setting up an instance of Cloudant or local CouchDB is a little complicated, so I set up a [Tasting server for self-hosted-livesync](https://olstaste.vrtmrz.net/). Try it out for free!~~   
+Now (30 May 2023) suspending while the server transfer.  
 Note: Please read "Limitations" carefully. Do not send your private vault.
 
 ## Information in StatusBar

manifest.json

@@ -1,7 +1,7 @@
 {
     "id": "obsidian-livesync",
     "name": "Self-hosted LiveSync",
-    "version": "0.17.31",
+    "version": "0.18.2",
     "minAppVersion": "0.9.12",
     "description": "Community implementation of self-hosted livesync. Reflect your vault changes to some other devices immediately. Please make sure to disable other synchronize solutions to avoid content corruption or duplication.",
     "author": "vorotamoroz",

package-lock.json

@@ -1,12 +1,12 @@
 {
     "name": "obsidian-livesync",
-    "version": "0.17.31",
+    "version": "0.18.2",
     "lockfileVersion": 2,
     "requires": true,
     "packages": {
         "": {
             "name": "obsidian-livesync",
-            "version": "0.17.31",
+            "version": "0.18.2",
             "license": "MIT",
             "dependencies": {
                 "diff-match-patch": "^1.0.5",

package.json

@@ -1,6 +1,6 @@
 {
     "name": "obsidian-livesync",
-    "version": "0.17.31",
+    "version": "0.18.2",
     "description": "Reflect your vault changes to some other devices immediately. Please make sure to disable other synchronize solutions to avoid content corruption or duplication.",
     "main": "main.js",
     "type": "module",

src/CmdHiddenFileSync.ts

@@ -0,0 +1,725 @@
+import { Notice, normalizePath, PluginManifest } from "./deps";
+import { EntryDoc, LoadedEntry, LOG_LEVEL, InternalFileEntry, FilePathWithPrefix, FilePath } from "./lib/src/types";
+import { InternalFileInfo, ICHeader, ICHeaderEnd } from "./types";
+import { delay, isDocContentSame } from "./lib/src/utils";
+import { Logger } from "./lib/src/logger";
+import { PouchDB } from "./lib/src/pouchdb-browser.js";
+import { disposeMemoObject, memoIfNotExist, memoObject, retrieveMemoObject, scheduleTask, trimPrefix, isIdOfInternalMetadata, PeriodicProcessor } from "./utils";
+import { WrappedNotice } from "./lib/src/wrapper";
+import { base64ToArrayBuffer, arrayBufferToBase64 } from "./lib/src/strbin";
+import { runWithLock } from "./lib/src/lock";
+import { Semaphore } from "./lib/src/semaphore";
+import { JsonResolveModal } from "./JsonResolveModal";
+import { LiveSyncCommands } from "./LiveSyncCommands";
+import { addPrefix, stripAllPrefixes } from "./lib/src/path";
+
+export class HiddenFileSync extends LiveSyncCommands {
+    periodicInternalFileScanProcessor: PeriodicProcessor = new PeriodicProcessor(this.plugin, async () => this.settings.syncInternalFiles && this.localDatabase.isReady && await this.syncInternalFilesAndDatabase("push", false));
+    confirmPopup: WrappedNotice = null;
+    get kvDB() {
+        return this.plugin.kvDB;
+    }
+    ensureDirectoryEx(fullPath: string) {
+        return this.plugin.ensureDirectoryEx(fullPath);
+    }
+    getConflictedDoc(path: FilePathWithPrefix, rev: string) {
+        return this.plugin.getConflictedDoc(path, rev);
+    }
+    onunload() {
+        this.periodicInternalFileScanProcessor?.disable();
+    }
+    onload(): void | Promise<void> {
+        this.plugin.addCommand({
+            id: "livesync-scaninternal",
+            name: "Sync hidden files",
+            callback: () => {
+                this.syncInternalFilesAndDatabase("safe", true);
+            },
+        });
+    }
+    async onInitializeDatabase(showNotice: boolean) {
+        if (this.settings.syncInternalFiles) {
+            try {
+                Logger("Synchronizing hidden files...");
+                await this.syncInternalFilesAndDatabase("push", showNotice);
+                Logger("Synchronizing hidden files done");
+            } catch (ex) {
+                Logger("Synchronizing hidden files failed");
+                Logger(ex, LOG_LEVEL.VERBOSE);
+            }
+        }
+    }
+    async beforeReplicate(showNotice: boolean) {
+        if (this.localDatabase.isReady && this.settings.syncInternalFiles && this.settings.syncInternalFilesBeforeReplication && !this.settings.watchInternalFileChanges) {
+            await this.syncInternalFilesAndDatabase("push", showNotice);
+        }
+    }
+    async onResume() {
+        this.periodicInternalFileScanProcessor?.disable();
+        if (this.plugin.suspended)
+            return;
+        if (this.settings.syncInternalFiles) {
+            await this.syncInternalFilesAndDatabase("safe", false);
+        }
+        this.periodicInternalFileScanProcessor.enable(this.settings.syncInternalFiles && this.settings.syncInternalFilesInterval ? (this.settings.syncInternalFilesInterval * 1000) : 0);
+    }
+    parseReplicationResultItem(docs: PouchDB.Core.ExistingDocument<EntryDoc>) {
+        return false;
+    }
+    realizeSettingSyncMode(): Promise<void> {
+        this.periodicInternalFileScanProcessor?.disable();
+        if (this.plugin.suspended)
+            return;
+        if (!this.plugin.isReady)
+            return;
+        this.periodicInternalFileScanProcessor.enable(this.settings.syncInternalFiles && this.settings.syncInternalFilesInterval ? (this.settings.syncInternalFilesInterval * 1000) : 0);
+        return;
+    }
+
+    procInternalFiles: string[] = [];
+    async execInternalFile() {
+        await runWithLock("execinternal", false, async () => {
+            const w = [...this.procInternalFiles];
+            this.procInternalFiles = [];
+            Logger(`Applying hidden ${w.length} files change...`);
+            await this.syncInternalFilesAndDatabase("pull", false, false, w);
+            Logger(`Applying hidden ${w.length} files changed`);
+        });
+    }
+    procInternalFile(filename: string) {
+        this.procInternalFiles.push(filename);
+        scheduleTask("procInternal", 500, async () => {
+            await this.execInternalFile();
+        });
+    }
+
+    recentProcessedInternalFiles = [] as string[];
+    async watchVaultRawEventsAsync(path: FilePath) {
+        const stat = await this.app.vault.adapter.stat(path);
+        // sometimes folder is coming.
+        if (stat && stat.type != "file")
+            return;
+        const storageMTime = ~~((stat && stat.mtime || 0) / 1000);
+        const key = `${path}-${storageMTime}`;
+        if (this.recentProcessedInternalFiles.contains(key)) {
+            //If recently processed, it may caused by self.
+            return;
+        }
+        this.recentProcessedInternalFiles = [key, ...this.recentProcessedInternalFiles].slice(0, 100);
+        // const id = await this.path2id(path, ICHeader);
+        const prefixedFileName = addPrefix(path, ICHeader);
+        const filesOnDB = await this.localDatabase.getDBEntryMeta(prefixedFileName);
+        const dbMTime = ~~((filesOnDB && filesOnDB.mtime || 0) / 1000);
+
+        // Skip unchanged file.
+        if (dbMTime == storageMTime) {
+            // Logger(`STORAGE --> DB:${path}: (hidden) Nothing changed`);
+            return;
+        }
+
+        // Do not compare timestamp. Always local data should be preferred except this plugin wrote one.
+        if (storageMTime == 0) {
+            await this.deleteInternalFileOnDatabase(path);
+        } else {
+            await this.storeInternalFileToDatabase({ path: path, ...stat });
+            const pluginDir = this.app.vault.configDir + "/plugins/";
+            const pluginFiles = ["manifest.json", "data.json", "style.css", "main.js"];
+            if (path.startsWith(pluginDir) && pluginFiles.some(e => path.endsWith(e)) && this.settings.usePluginSync) {
+                const pluginName = trimPrefix(path, pluginDir).split("/")[0];
+                await this.plugin.addOnPluginAndTheirSettings.sweepPlugin(false, pluginName);
+            }
+        }
+
+    }
+
+    async resolveConflictOnInternalFiles() {
+        // Scan all conflicted internal files
+        const conflicted = this.localDatabase.findEntries(ICHeader, ICHeaderEnd, { conflicts: true });
+        for await (const doc of conflicted) {
+            if (!("_conflicts" in doc))
+                continue;
+            if (isIdOfInternalMetadata(doc._id)) {
+                await this.resolveConflictOnInternalFile(doc.path);
+            }
+        }
+    }
+
+    async resolveConflictOnInternalFile(path: FilePathWithPrefix): Promise<boolean> {
+        try {
+            // Retrieve data
+            const id = await this.path2id(path, ICHeader);
+            const doc = await this.localDatabase.getRaw(id, { conflicts: true });
+            // If there is no conflict, return with false.
+            if (!("_conflicts" in doc))
+                return false;
+            if (doc._conflicts.length == 0)
+                return false;
+            Logger(`Hidden file conflicted:${path}`);
+            const conflicts = doc._conflicts.sort((a, b) => Number(a.split("-")[0]) - Number(b.split("-")[0]));
+            const revA = doc._rev;
+            const revB = conflicts[0];
+
+            if (path.endsWith(".json")) {
+                const conflictedRev = conflicts[0];
+                const conflictedRevNo = Number(conflictedRev.split("-")[0]);
+                //Search 
+                const revFrom = (await this.localDatabase.getRaw<EntryDoc>(id, { revs_info: true }));
+                const commonBase = revFrom._revs_info.filter(e => e.status == "available" && Number(e.rev.split("-")[0]) < conflictedRevNo).first()?.rev ?? "";
+                const result = await this.plugin.mergeObject(path, commonBase, doc._rev, conflictedRev);
+                if (result) {
+                    Logger(`Object merge:${path}`, LOG_LEVEL.INFO);
+                    const filename = stripAllPrefixes(path);
+                    const isExists = await this.app.vault.adapter.exists(filename);
+                    if (!isExists) {
+                        await this.ensureDirectoryEx(filename);
+                    }
+                    await this.app.vault.adapter.write(filename, result);
+                    const stat = await this.app.vault.adapter.stat(filename);
+                    await this.storeInternalFileToDatabase({ path: filename, ...stat });
+                    await this.extractInternalFileFromDatabase(filename);
+                    await this.localDatabase.removeRaw(id, revB);
+                    return this.resolveConflictOnInternalFile(path);
+                } else {
+                    Logger(`Object merge is not applicable.`, LOG_LEVEL.VERBOSE);
+                }
+
+                const docAMerge = await this.localDatabase.getDBEntry(path, { rev: revA });
+                const docBMerge = await this.localDatabase.getDBEntry(path, { rev: revB });
+                if (docAMerge != false && docBMerge != false) {
+                    if (await this.showJSONMergeDialogAndMerge(docAMerge, docBMerge)) {
+                        await delay(200);
+                        // Again for other conflicted revisions.
+                        return this.resolveConflictOnInternalFile(path);
+                    }
+                    return false;
+                }
+            }
+            const revBDoc = await this.localDatabase.getRaw(id, { rev: revB });
+            // determine which revision should been deleted.
+            // simply check modified time
+            const mtimeA = ("mtime" in doc && doc.mtime) || 0;
+            const mtimeB = ("mtime" in revBDoc && revBDoc.mtime) || 0;
+            // Logger(`Revisions:${new Date(mtimeA).toLocaleString} and ${new Date(mtimeB).toLocaleString}`);
+            // console.log(`mtime:${mtimeA} - ${mtimeB}`);
+            const delRev = mtimeA < mtimeB ? revA : revB;
+            // delete older one.
+            await this.localDatabase.removeRaw(id, delRev);
+            Logger(`Older one has been deleted:${path}`);
+            // check the file again 
+            return this.resolveConflictOnInternalFile(path);
+        } catch (ex) {
+            Logger(`Failed to resolve conflict (Hidden): ${path}`);
+            Logger(ex, LOG_LEVEL.VERBOSE);
+            return false;
+        }
+    }
+
+    //TODO: Tidy up. Even though it is experimental feature, So dirty...
+    async syncInternalFilesAndDatabase(direction: "push" | "pull" | "safe" | "pullForce" | "pushForce", showMessage: boolean, files: InternalFileInfo[] | false = false, targetFiles: string[] | false = false) {
+        await this.resolveConflictOnInternalFiles();
+        const logLevel = showMessage ? LOG_LEVEL.NOTICE : LOG_LEVEL.INFO;
+        Logger("Scanning hidden files.", logLevel, "sync_internal");
+        const ignorePatterns = this.settings.syncInternalFilesIgnorePatterns
+            .replace(/\n| /g, "")
+            .split(",").filter(e => e).map(e => new RegExp(e, "i"));
+        if (!files)
+            files = await this.scanInternalFiles();
+        const filesOnDB = ((await this.localDatabase.allDocsRaw({ startkey: ICHeader, endkey: ICHeaderEnd, include_docs: true })).rows.map(e => e.doc) as InternalFileEntry[]).filter(e => !e.deleted);
+        const allFileNamesSrc = [...new Set([...files.map(e => normalizePath(e.path)), ...filesOnDB.map(e => stripAllPrefixes(this.getPath(e)))])];
+        const allFileNames = allFileNamesSrc.filter(filename => !targetFiles || (targetFiles && targetFiles.indexOf(filename) !== -1));
+        function compareMTime(a: number, b: number) {
+            const wa = ~~(a / 1000);
+            const wb = ~~(b / 1000);
+            const diff = wa - wb;
+            return diff;
+        }
+
+        const fileCount = allFileNames.length;
+        let processed = 0;
+        let filesChanged = 0;
+        // count updated files up as like this below:
+        // .obsidian: 2
+        // .obsidian/workspace: 1
+        // .obsidian/plugins: 1
+        // .obsidian/plugins/recent-files-obsidian: 1
+        // .obsidian/plugins/recent-files-obsidian/data.json: 1
+        const updatedFolders: { [key: string]: number; } = {};
+        const countUpdatedFolder = (path: string) => {
+            const pieces = path.split("/");
+            let c = pieces.shift();
+            let pathPieces = "";
+            filesChanged++;
+            while (c) {
+                pathPieces += (pathPieces != "" ? "/" : "") + c;
+                pathPieces = normalizePath(pathPieces);
+                if (!(pathPieces in updatedFolders)) {
+                    updatedFolders[pathPieces] = 0;
+                }
+                updatedFolders[pathPieces]++;
+                c = pieces.shift();
+            }
+        };
+        const p = [] as Promise<void>[];
+        const semaphore = Semaphore(10);
+        // Cache update time information for files which have already been processed (mainly for files that were skipped due to the same content)
+        let caches: { [key: string]: { storageMtime: number; docMtime: number; }; } = {};
+        caches = await this.kvDB.get<{ [key: string]: { storageMtime: number; docMtime: number; }; }>("diff-caches-internal") || {};
+        for (const filename of allFileNames) {
+            if (!filename) continue;
+            processed++;
+            if (processed % 100 == 0)
+                Logger(`Hidden file: ${processed}/${fileCount}`, logLevel, "sync_internal");
+            if (ignorePatterns.some(e => filename.match(e)))
+                continue;
+
+            const fileOnStorage = files.find(e => e.path == filename);
+            const fileOnDatabase = filesOnDB.find(e => stripAllPrefixes(this.getPath(e)) == filename);
+            const addProc = async (p: () => Promise<void>): Promise<void> => {
+                const releaser = await semaphore.acquire(1);
+                try {
+                    return p();
+                } catch (ex) {
+                    Logger("Some process failed", logLevel);
+                    Logger(ex);
+                } finally {
+                    releaser();
+                }
+            };
+            const cache = filename in caches ? caches[filename] : { storageMtime: 0, docMtime: 0 };
+
+            p.push(addProc(async () => {
+                const xFileOnStorage = fileOnStorage;
+                const xFileOnDatabase = fileOnDatabase;
+                if (xFileOnStorage && xFileOnDatabase) {
+                    // Both => Synchronize
+                    if ((direction != "pullForce" && direction != "pushForce") && xFileOnDatabase.mtime == cache.docMtime && xFileOnStorage.mtime == cache.storageMtime) {
+                        return;
+                    }
+                    const nw = compareMTime(xFileOnStorage.mtime, xFileOnDatabase.mtime);
+                    if (nw > 0 || direction == "pushForce") {
+                        await this.storeInternalFileToDatabase(xFileOnStorage);
+                    }
+                    if (nw < 0 || direction == "pullForce") {
+                        // skip if not extraction performed.
+                        if (!await this.extractInternalFileFromDatabase(filename))
+                            return;
+                    }
+                    // If process successfully updated or file contents are same, update cache.
+                    cache.docMtime = xFileOnDatabase.mtime;
+                    cache.storageMtime = xFileOnStorage.mtime;
+                    caches[filename] = cache;
+                    countUpdatedFolder(filename);
+                } else if (!xFileOnStorage && xFileOnDatabase) {
+                    if (direction == "push" || direction == "pushForce") {
+                        if (xFileOnDatabase.deleted)
+                            return;
+                        await this.deleteInternalFileOnDatabase(filename, false);
+                    } else if (direction == "pull" || direction == "pullForce") {
+                        if (await this.extractInternalFileFromDatabase(filename)) {
+                            countUpdatedFolder(filename);
+                        }
+                    } else if (direction == "safe") {
+                        if (xFileOnDatabase.deleted)
+                            return;
+                        if (await this.extractInternalFileFromDatabase(filename)) {
+                            countUpdatedFolder(filename);
+                        }
+                    }
+                } else if (xFileOnStorage && !xFileOnDatabase) {
+                    await this.storeInternalFileToDatabase(xFileOnStorage);
+                } else {
+                    throw new Error("Invalid state on hidden file sync");
+                    // Something corrupted?
+                }
+            }));
+        }
+        await Promise.all(p);
+        await this.kvDB.set("diff-caches-internal", caches);
+
+        // When files has been retrieved from the database. they must be reloaded.
+        if (direction == "pull" || direction == "pullForce" && filesChanged != 0) {
+            const configDir = normalizePath(this.app.vault.configDir);
+            // Show notification to restart obsidian when something has been changed in configDir.
+            if (configDir in updatedFolders) {
+                // Numbers of updated files that is below of configDir.
+                let updatedCount = updatedFolders[configDir];
+                try {
+                    //@ts-ignore
+                    const manifests = Object.values(this.app.plugins.manifests) as any as PluginManifest[];
+                    //@ts-ignore
+                    const enabledPlugins = this.app.plugins.enabledPlugins as Set<string>;
+                    const enabledPluginManifests = manifests.filter(e => enabledPlugins.has(e.id));
+                    for (const manifest of enabledPluginManifests) {
+                        if (manifest.dir in updatedFolders) {
+                            // If notified about plug-ins, reloading Obsidian may not be necessary.
+                            updatedCount -= updatedFolders[manifest.dir];
+                            const updatePluginId = manifest.id;
+                            const updatePluginName = manifest.name;
+                            const fragment = createFragment((doc) => {
+                                doc.createEl("span", null, (a) => {
+                                    a.appendText(`Files in ${updatePluginName} has been updated, Press `);
+                                    a.appendChild(a.createEl("a", null, (anchor) => {
+                                        anchor.text = "HERE";
+                                        anchor.addEventListener("click", async () => {
+                                            Logger(`Unloading plugin: ${updatePluginName}`, LOG_LEVEL.NOTICE, "plugin-reload-" + updatePluginId);
+                                            // @ts-ignore
+                                            await this.app.plugins.unloadPlugin(updatePluginId);
+                                            // @ts-ignore
+                                            await this.app.plugins.loadPlugin(updatePluginId);
+                                            Logger(`Plugin reloaded: ${updatePluginName}`, LOG_LEVEL.NOTICE, "plugin-reload-" + updatePluginId);
+                                        });
+                                    }));
+
+                                    a.appendText(` to reload ${updatePluginName}, or press elsewhere to dismiss this message.`);
+                                });
+                            });
+
+                            const updatedPluginKey = "popupUpdated-" + updatePluginId;
+                            scheduleTask(updatedPluginKey, 1000, async () => {
+                                const popup = await memoIfNotExist(updatedPluginKey, () => new Notice(fragment, 0));
+                                //@ts-ignore
+                                const isShown = popup?.noticeEl?.isShown();
+                                if (!isShown) {
+                                    memoObject(updatedPluginKey, new Notice(fragment, 0));
+                                }
+                                scheduleTask(updatedPluginKey + "-close", 20000, () => {
+                                    const popup = retrieveMemoObject<Notice>(updatedPluginKey);
+                                    if (!popup)
+                                        return;
+                                    //@ts-ignore
+                                    if (popup?.noticeEl?.isShown()) {
+                                        popup.hide();
+                                    }
+                                    disposeMemoObject(updatedPluginKey);
+                                });
+                            });
+                        }
+                    }
+                } catch (ex) {
+                    Logger("Error on checking plugin status.");
+                    Logger(ex, LOG_LEVEL.VERBOSE);
+
+                }
+
+                // If something changes left, notify for reloading Obsidian.
+                if (updatedCount != 0) {
+                    const fragment = createFragment((doc) => {
+                        doc.createEl("span", null, (a) => {
+                            a.appendText(`Hidden files have been synchronized, Press `);
+                            a.appendChild(a.createEl("a", null, (anchor) => {
+                                anchor.text = "HERE";
+                                anchor.addEventListener("click", () => {
+                                    // @ts-ignore
+                                    this.app.commands.executeCommandById("app:reload");
+                                });
+                            }));
+
+                            a.appendText(` to reload obsidian, or press elsewhere to dismiss this message.`);
+                        });
+                    });
+
+                    scheduleTask("popupUpdated-" + configDir, 1000, () => {
+                        //@ts-ignore
+                        const isShown = this.confirmPopup?.noticeEl?.isShown();
+                        if (!isShown) {
+                            this.confirmPopup = new Notice(fragment, 0);
+                        }
+                        scheduleTask("popupClose" + configDir, 20000, () => {
+                            this.confirmPopup?.hide();
+                            this.confirmPopup = null;
+                        });
+                    });
+                }
+            }
+        }
+
+        Logger(`Hidden files scanned: ${filesChanged} files had been modified`, logLevel, "sync_internal");
+    }
+
+    async storeInternalFileToDatabase(file: InternalFileInfo, forceWrite = false) {
+        const id = await this.path2id(file.path, ICHeader);
+        const prefixedFileName = addPrefix(file.path, ICHeader);
+        const contentBin = await this.app.vault.adapter.readBinary(file.path);
+        let content: string[];
+        try {
+            content = await arrayBufferToBase64(contentBin);
+        } catch (ex) {
+            Logger(`The file ${file.path} could not be encoded`);
+            Logger(ex, LOG_LEVEL.VERBOSE);
+            return false;
+        }
+        const mtime = file.mtime;
+        return await runWithLock("file-" + prefixedFileName, false, async () => {
+            try {
+                const old = await this.localDatabase.getDBEntry(prefixedFileName, null, false, false);
+                let saveData: LoadedEntry;
+                if (old === false) {
+                    saveData = {
+                        _id: id,
+                        path: prefixedFileName,
+                        data: content,
+                        mtime,
+                        ctime: mtime,
+                        datatype: "newnote",
+                        size: file.size,
+                        children: [],
+                        deleted: false,
+                        type: "newnote",
+                    };
+                } else {
+                    if (isDocContentSame(old.data, content) && !forceWrite) {
+                        // Logger(`STORAGE --> DB:${file.path}: (hidden) Not changed`, LOG_LEVEL.VERBOSE);
+                        return;
+                    }
+                    saveData =
+                    {
+                        ...old,
+                        data: content,
+                        mtime,
+                        size: file.size,
+                        datatype: "newnote",
+                        children: [],
+                        deleted: false,
+                        type: "newnote",
+                    };
+                }
+                const ret = await this.localDatabase.putDBEntry(saveData, true);
+                Logger(`STORAGE --> DB:${file.path}: (hidden) Done`);
+                return ret;
+            } catch (ex) {
+                Logger(`STORAGE --> DB:${file.path}: (hidden) Failed`);
+                Logger(ex, LOG_LEVEL.VERBOSE);
+                return false;
+            }
+        });
+    }
+
+    async deleteInternalFileOnDatabase(filename: FilePath, forceWrite = false) {
+        const id = await this.path2id(filename, ICHeader);
+        const prefixedFileName = addPrefix(filename, ICHeader);
+        const mtime = new Date().getTime();
+        await runWithLock("file-" + prefixedFileName, false, async () => {
+            try {
+                const old = await this.localDatabase.getDBEntry(prefixedFileName, null, false, false) as InternalFileEntry | false;
+                let saveData: InternalFileEntry;
+                if (old === false) {
+                    saveData = {
+                        _id: id,
+                        path: prefixedFileName,
+                        mtime,
+                        ctime: mtime,
+                        size: 0,
+                        children: [],
+                        deleted: true,
+                        type: "newnote",
+                    };
+                } else {
+                    if (old.deleted) {
+                        Logger(`STORAGE -x> DB:${filename}: (hidden) already deleted`);
+                        return;
+                    }
+                    saveData =
+                    {
+                        ...old,
+                        mtime,
+                        size: 0,
+                        children: [],
+                        deleted: true,
+                        type: "newnote",
+                    };
+                }
+                await this.localDatabase.putRaw(saveData);
+                Logger(`STORAGE -x> DB:${filename}: (hidden) Done`);
+            } catch (ex) {
+                Logger(`STORAGE -x> DB:${filename}: (hidden) Failed`);
+                Logger(ex, LOG_LEVEL.VERBOSE);
+                return false;
+            }
+        });
+    }
+
+    async extractInternalFileFromDatabase(filename: FilePath, force = false) {
+        const isExists = await this.app.vault.adapter.exists(filename);
+        const prefixedFileName = addPrefix(filename, ICHeader);
+
+        return await runWithLock("file-" + prefixedFileName, false, async () => {
+            try {
+                // Check conflicted status 
+                //TODO option
+                const fileOnDB = await this.localDatabase.getDBEntry(prefixedFileName, { conflicts: true }, false, false);
+                if (fileOnDB === false)
+                    throw new Error(`File not found on database.:${filename}`);
+                // Prevent overwrite for Prevent overwriting while some conflicted revision exists.
+                if (fileOnDB?._conflicts?.length) {
+                    Logger(`Hidden file ${filename} has conflicted revisions, to keep in safe, writing to storage has been prevented`, LOG_LEVEL.INFO);
+                    return;
+                }
+                const deleted = "deleted" in fileOnDB ? fileOnDB.deleted : false;
+                if (deleted) {
+                    if (!isExists) {
+                        Logger(`STORAGE <x- DB:${filename}: deleted (hidden) Deleted on DB, but the file is  already not found on storage.`);
+                    } else {
+                        Logger(`STORAGE <x- DB:${filename}: deleted (hidden).`);
+                        await this.app.vault.adapter.remove(filename);
+                        try {
+                            //@ts-ignore internalAPI
+                            await app.vault.adapter.reconcileInternalFile(filename);
+                        } catch (ex) {
+                            Logger("Failed to call internal API(reconcileInternalFile)", LOG_LEVEL.VERBOSE);
+                            Logger(ex, LOG_LEVEL.VERBOSE);
+                        }
+                    }
+                    return true;
+                }
+                if (!isExists) {
+                    await this.ensureDirectoryEx(filename);
+                    await this.app.vault.adapter.writeBinary(filename, base64ToArrayBuffer(fileOnDB.data), { mtime: fileOnDB.mtime, ctime: fileOnDB.ctime });
+                    try {
+                        //@ts-ignore internalAPI
+                        await app.vault.adapter.reconcileInternalFile(filename);
+                    } catch (ex) {
+                        Logger("Failed to call internal API(reconcileInternalFile)", LOG_LEVEL.VERBOSE);
+                        Logger(ex, LOG_LEVEL.VERBOSE);
+                    }
+                    Logger(`STORAGE <-- DB:${filename}: written (hidden,new${force ? ", force" : ""})`);
+                    return true;
+                } else {
+                    const contentBin = await this.app.vault.adapter.readBinary(filename);
+                    const content = await arrayBufferToBase64(contentBin);
+                    if (content == fileOnDB.data && !force) {
+                        // Logger(`STORAGE <-- DB:${filename}: skipped (hidden) Not changed`, LOG_LEVEL.VERBOSE);
+                        return true;
+                    }
+                    await this.app.vault.adapter.writeBinary(filename, base64ToArrayBuffer(fileOnDB.data), { mtime: fileOnDB.mtime, ctime: fileOnDB.ctime });
+                    try {
+                        //@ts-ignore internalAPI
+                        await app.vault.adapter.reconcileInternalFile(filename);
+                    } catch (ex) {
+                        Logger("Failed to call internal API(reconcileInternalFile)", LOG_LEVEL.VERBOSE);
+                        Logger(ex, LOG_LEVEL.VERBOSE);
+                    }
+                    Logger(`STORAGE <-- DB:${filename}: written (hidden, overwrite${force ? ", force" : ""})`);
+                    return true;
+
+                }
+            } catch (ex) {
+                Logger(`STORAGE <-- DB:${filename}: written (hidden, overwrite${force ? ", force" : ""}) Failed`);
+                Logger(ex, LOG_LEVEL.VERBOSE);
+                return false;
+            }
+        });
+    }
+
+
+
+    showJSONMergeDialogAndMerge(docA: LoadedEntry, docB: LoadedEntry): Promise<boolean> {
+        return new Promise((res) => {
+            Logger("Opening data-merging dialog", LOG_LEVEL.VERBOSE);
+            const docs = [docA, docB];
+            const path = stripAllPrefixes(docA.path);
+            const modal = new JsonResolveModal(this.app, path, [docA, docB], async (keep, result) => {
+                // modal.close();
+                try {
+                    const filename = path;
+                    let needFlush = false;
+                    if (!result && !keep) {
+                        Logger(`Skipped merging: ${filename}`);
+                    }
+                    //Delete old revisions
+                    if (result || keep) {
+                        for (const doc of docs) {
+                            if (doc._rev != keep) {
+                                if (await this.localDatabase.deleteDBEntry(this.getPath(doc), { rev: doc._rev })) {
+                                    Logger(`Conflicted revision has been deleted: ${filename}`);
+                                    needFlush = true;
+                                }
+                            }
+                        }
+                    }
+                    if (!keep && result) {
+                        const isExists = await this.app.vault.adapter.exists(filename);
+                        if (!isExists) {
+                            await this.ensureDirectoryEx(filename);
+                        }
+                        await this.app.vault.adapter.write(filename, result);
+                        const stat = await this.app.vault.adapter.stat(filename);
+                        await this.storeInternalFileToDatabase({ path: filename, ...stat }, true);
+                        try {
+                            //@ts-ignore internalAPI
+                            await app.vault.adapter.reconcileInternalFile(filename);
+                        } catch (ex) {
+                            Logger("Failed to call internal API(reconcileInternalFile)", LOG_LEVEL.VERBOSE);
+                            Logger(ex, LOG_LEVEL.VERBOSE);
+                        }
+                        Logger(`STORAGE <-- DB:${filename}: written (hidden,merged)`);
+                    }
+                    if (needFlush) {
+                        await this.extractInternalFileFromDatabase(filename, false);
+                        Logger(`STORAGE --> DB:${filename}: extracted (hidden,merged)`);
+                    }
+                    res(true);
+                } catch (ex) {
+                    Logger("Could not merge conflicted json");
+                    Logger(ex, LOG_LEVEL.VERBOSE);
+                    res(false);
+                }
+            });
+            modal.open();
+        });
+    }
+
+    async scanInternalFiles(): Promise<InternalFileInfo[]> {
+        const ignoreFilter = this.settings.syncInternalFilesIgnorePatterns
+            .replace(/\n| /g, "")
+            .split(",").filter(e => e).map(e => new RegExp(e, "i"));
+        const root = this.app.vault.getRoot();
+        const findRoot = root.path;
+        const filenames = (await this.getFiles(findRoot, [], null, ignoreFilter)).filter(e => e.startsWith(".")).filter(e => !e.startsWith(".trash"));
+        const files = filenames.map(async (e) => {
+            return {
+                path: e as FilePath,
+                stat: await this.app.vault.adapter.stat(e)
+            };
+        });
+        const result: InternalFileInfo[] = [];
+        for (const f of files) {
+            const w = await f;
+            result.push({
+                ...w,
+                ...w.stat
+            });
+        }
+        return result;
+    }
+
+
+
+    async getFiles(
+        path: string,
+        ignoreList: string[],
+        filter: RegExp[],
+        ignoreFilter: RegExp[]
+    ) {
+
+        const w = await this.app.vault.adapter.list(path);
+        let files = [
+            ...w.files
+                .filter((e) => !ignoreList.some((ee) => e.endsWith(ee)))
+                .filter((e) => !filter || filter.some((ee) => e.match(ee)))
+                .filter((e) => !ignoreFilter || ignoreFilter.every((ee) => !e.match(ee))),
+        ];
+
+        L1: for (const v of w.folders) {
+            for (const ignore of ignoreList) {
+                if (v.endsWith(ignore)) {
+                    continue L1;
+                }
+            }
+            if (ignoreFilter && ignoreFilter.some(e => v.match(e))) {
+                continue L1;
+            }
+            files = files.concat(await this.getFiles(v, ignoreList, filter, ignoreFilter));
+        }
+        return files;
+    }
+}

src/CmdPluginAndTheirSettings.ts

@@ -0,0 +1,314 @@
+import { normalizePath, PluginManifest } from "./deps";
+import { DocumentID, EntryDoc, FilePathWithPrefix, LoadedEntry, LOG_LEVEL } from "./lib/src/types";
+import { PluginDataEntry, PERIODIC_PLUGIN_SWEEP, PluginList, DevicePluginList, PSCHeader, PSCHeaderEnd } from "./types";
+import { getDocData, isDocContentSame } from "./lib/src/utils";
+import { Logger } from "./lib/src/logger";
+import { PouchDB } from "./lib/src/pouchdb-browser.js";
+import { isPluginMetadata, PeriodicProcessor } from "./utils";
+import { PluginDialogModal } from "./dialogs";
+import { NewNotice } from "./lib/src/wrapper";
+import { versionNumberString2Number } from "./lib/src/strbin";
+import { runWithLock } from "./lib/src/lock";
+import { LiveSyncCommands } from "./LiveSyncCommands";
+
+export class PluginAndTheirSettings extends LiveSyncCommands {
+
+    get deviceAndVaultName() {
+        return this.plugin.deviceAndVaultName;
+    }
+    pluginDialog: PluginDialogModal = null;
+    periodicPluginSweepProcessor = new PeriodicProcessor(this.plugin, async () => await this.sweepPlugin(false));
+
+    showPluginSyncModal() {
+        if (this.pluginDialog != null) {
+            this.pluginDialog.open();
+        } else {
+            this.pluginDialog = new PluginDialogModal(this.app, this.plugin);
+            this.pluginDialog.open();
+        }
+    }
+
+    hidePluginSyncModal() {
+        if (this.pluginDialog != null) {
+            this.pluginDialog.close();
+            this.pluginDialog = null;
+        }
+    }
+    onload(): void | Promise<void> {
+        this.plugin.addCommand({
+            id: "livesync-plugin-dialog",
+            name: "Show Plugins and their settings",
+            callback: () => {
+                this.showPluginSyncModal();
+            },
+        });
+    }
+    onunload() {
+        this.hidePluginSyncModal();
+        this.periodicPluginSweepProcessor?.disable();
+    }
+    parseReplicationResultItem(doc: PouchDB.Core.ExistingDocument<EntryDoc>) {
+        if (isPluginMetadata(doc._id)) {
+            if (this.settings.notifyPluginOrSettingUpdated) {
+                this.triggerCheckPluginUpdate();
+                return true;
+            }
+        }
+        return false;
+    }
+    async beforeReplicate(showMessage: boolean) {
+        if (this.settings.autoSweepPlugins) {
+            await this.sweepPlugin(showMessage);
+        }
+    }
+    async onResume() {
+        if (this.plugin.suspended)
+            return;
+        if (this.settings.autoSweepPlugins) {
+            await this.sweepPlugin(false);
+        }
+        this.periodicPluginSweepProcessor.enable(this.settings.autoSweepPluginsPeriodic && !this.settings.watchInternalFileChanges ? (PERIODIC_PLUGIN_SWEEP * 1000) : 0);
+    }
+    async onInitializeDatabase(showNotice: boolean) {
+        if (this.settings.usePluginSync) {
+            try {
+                Logger("Scanning plugins...");
+                await this.sweepPlugin(showNotice);
+                Logger("Scanning plugins done");
+            } catch (ex) {
+                Logger("Scanning plugins  failed");
+                Logger(ex, LOG_LEVEL.VERBOSE);
+            }
+
+        }
+    }
+
+    async realizeSettingSyncMode() {
+        this.periodicPluginSweepProcessor?.disable();
+        if (this.plugin.suspended)
+            return;
+        if (this.settings.autoSweepPlugins) {
+            await this.sweepPlugin(false);
+        }
+        this.periodicPluginSweepProcessor.enable(this.settings.autoSweepPluginsPeriodic && !this.settings.watchInternalFileChanges ? (PERIODIC_PLUGIN_SWEEP * 1000) : 0);
+    }
+
+    triggerCheckPluginUpdate() {
+        (async () => await this.checkPluginUpdate())();
+    }
+
+
+    async getPluginList(): Promise<{ plugins: PluginList; allPlugins: DevicePluginList; thisDevicePlugins: DevicePluginList; }> {
+        const docList = await this.localDatabase.allDocsRaw<PluginDataEntry>({ startkey: PSCHeader, endkey: PSCHeaderEnd, include_docs: false });
+        const oldDocs: PluginDataEntry[] = ((await Promise.all(docList.rows.map(async (e) => await this.localDatabase.getDBEntry(e.id as FilePathWithPrefix /* WARN!! THIS SHOULD BE WRAPPED */)))).filter((e) => e !== false) as LoadedEntry[]).map((e) => JSON.parse(getDocData(e.data)));
+        const plugins: { [key: string]: PluginDataEntry[]; } = {};
+        const allPlugins: { [key: string]: PluginDataEntry; } = {};
+        const thisDevicePlugins: { [key: string]: PluginDataEntry; } = {};
+        for (const v of oldDocs) {
+            if (typeof plugins[v.deviceVaultName] === "undefined") {
+                plugins[v.deviceVaultName] = [];
+            }
+            plugins[v.deviceVaultName].push(v);
+            allPlugins[v._id] = v;
+            if (v.deviceVaultName == this.deviceAndVaultName) {
+                thisDevicePlugins[v.manifest.id] = v;
+            }
+        }
+        return { plugins, allPlugins, thisDevicePlugins };
+    }
+
+    async checkPluginUpdate() {
+        if (!this.plugin.settings.usePluginSync)
+            return;
+        await this.sweepPlugin(false);
+        const { allPlugins, thisDevicePlugins } = await this.getPluginList();
+        const arrPlugins = Object.values(allPlugins);
+        let updateFound = false;
+        for (const plugin of arrPlugins) {
+            const ownPlugin = thisDevicePlugins[plugin.manifest.id];
+            if (ownPlugin) {
+                const remoteVersion = versionNumberString2Number(plugin.manifest.version);
+                const ownVersion = versionNumberString2Number(ownPlugin.manifest.version);
+                if (remoteVersion > ownVersion) {
+                    updateFound = true;
+                }
+                if (((plugin.mtime / 1000) | 0) > ((ownPlugin.mtime / 1000) | 0) && (plugin.dataJson ?? "") != (ownPlugin.dataJson ?? "")) {
+                    updateFound = true;
+                }
+            }
+        }
+        if (updateFound) {
+            const fragment = createFragment((doc) => {
+                doc.createEl("a", null, (a) => {
+                    a.text = "There're some new plugins or their settings";
+                    a.addEventListener("click", () => this.showPluginSyncModal());
+                });
+            });
+            NewNotice(fragment, 10000);
+        } else {
+            Logger("Everything is up to date.", LOG_LEVEL.NOTICE);
+        }
+    }
+
+    async sweepPlugin(showMessage = false, specificPluginPath = "") {
+        if (!this.settings.usePluginSync)
+            return;
+        if (!this.localDatabase.isReady)
+            return;
+        // @ts-ignore
+        const pl = this.app.plugins;
+        const manifests: PluginManifest[] = Object.values(pl.manifests);
+        let specificPlugin = "";
+        if (specificPluginPath != "") {
+            specificPlugin = manifests.find(e => e.dir.endsWith("/" + specificPluginPath))?.id ?? "";
+        }
+        await runWithLock("sweepplugin", true, async () => {
+            const logLevel = showMessage ? LOG_LEVEL.NOTICE : LOG_LEVEL.INFO;
+            if (!this.deviceAndVaultName) {
+                Logger("You have to set your device and vault name.", LOG_LEVEL.NOTICE);
+                return;
+            }
+            Logger("Scanning plugins", logLevel);
+            const oldDocs = await this.localDatabase.allDocsRaw<EntryDoc>({
+                startkey: `ps:${this.deviceAndVaultName}-${specificPlugin}`,
+                endkey: `ps:${this.deviceAndVaultName}-${specificPlugin}\u{10ffff}`,
+                include_docs: true,
+            });
+            // Logger("OLD DOCS.", LOG_LEVEL.VERBOSE);
+            // sweep current plugin.
+            const procs = manifests.map(async (m) => {
+                const pluginDataEntryID = `ps:${this.deviceAndVaultName}-${m.id}` as DocumentID;
+                try {
+                    if (specificPlugin && m.id != specificPlugin) {
+                        return;
+                    }
+                    Logger(`Reading plugin:${m.name}(${m.id})`, LOG_LEVEL.VERBOSE);
+                    const path = normalizePath(m.dir) + "/";
+                    const adapter = this.app.vault.adapter;
+                    const files = ["manifest.json", "main.js", "styles.css", "data.json"];
+                    const pluginData: { [key: string]: string; } = {};
+                    for (const file of files) {
+                        const thePath = path + file;
+                        if (await adapter.exists(thePath)) {
+                            pluginData[file] = await adapter.read(thePath);
+                        }
+                    }
+                    let mtime = 0;
+                    if (await adapter.exists(path + "/data.json")) {
+                        mtime = (await adapter.stat(path + "/data.json")).mtime;
+                    }
+
+                    const p: PluginDataEntry = {
+                        _id: pluginDataEntryID,
+                        dataJson: pluginData["data.json"],
+                        deviceVaultName: this.deviceAndVaultName,
+                        mainJs: pluginData["main.js"],
+                        styleCss: pluginData["styles.css"],
+                        manifest: m,
+                        manifestJson: pluginData["manifest.json"],
+                        mtime: mtime,
+                        type: "plugin",
+                    };
+                    const d: LoadedEntry = {
+                        _id: p._id,
+                        path: p._id as string as FilePathWithPrefix,
+                        data: JSON.stringify(p),
+                        ctime: mtime,
+                        mtime: mtime,
+                        size: 0,
+                        children: [],
+                        datatype: "plain",
+                        type: "plain"
+                    };
+                    Logger(`check diff:${m.name}(${m.id})`, LOG_LEVEL.VERBOSE);
+                    await runWithLock("plugin-" + m.id, false, async () => {
+                        const old = await this.localDatabase.getDBEntry(p._id as string as FilePathWithPrefix /* This also should be explained */, null, false, false);
+                        if (old !== false) {
+                            const oldData = { data: old.data, deleted: old._deleted };
+                            const newData = { data: d.data, deleted: d._deleted };
+                            if (isDocContentSame(oldData.data, newData.data) && oldData.deleted == newData.deleted) {
+                                Logger(`Nothing changed:${m.name}`);
+                                return;
+                            }
+                        }
+                        await this.localDatabase.putDBEntry(d);
+                        Logger(`Plugin saved:${m.name}`, logLevel);
+                    });
+                } catch (ex) {
+                    Logger(`Plugin save failed:${m.name}`, LOG_LEVEL.NOTICE);
+                } finally {
+                    oldDocs.rows = oldDocs.rows.filter((e) => e.id != pluginDataEntryID);
+                }
+                //remove saved plugin data.
+            }
+            );
+
+            await Promise.all(procs);
+
+            const delDocs = oldDocs.rows.map((e) => {
+                // e.doc._deleted = true;
+                if (e.doc.type == "newnote" || e.doc.type == "plain") {
+                    e.doc.deleted = true;
+                    if (this.settings.deleteMetadataOfDeletedFiles) {
+                        e.doc._deleted = true;
+                    }
+                } else {
+                    e.doc._deleted = true;
+                }
+                return e.doc;
+            });
+            Logger(`Deleting old plugin:(${delDocs.length})`, LOG_LEVEL.VERBOSE);
+            await this.localDatabase.bulkDocsRaw(delDocs);
+            Logger(`Scan plugin done.`, logLevel);
+        });
+    }
+
+    async applyPluginData(plugin: PluginDataEntry) {
+        await runWithLock("plugin-" + plugin.manifest.id, false, async () => {
+            const pluginTargetFolderPath = normalizePath(plugin.manifest.dir) + "/";
+            const adapter = this.app.vault.adapter;
+            // @ts-ignore
+            const stat = this.app.plugins.enabledPlugins.has(plugin.manifest.id) == true;
+            if (stat) {
+                // @ts-ignore
+                await this.app.plugins.unloadPlugin(plugin.manifest.id);
+                Logger(`Unload plugin:${plugin.manifest.id}`, LOG_LEVEL.NOTICE);
+            }
+            if (plugin.dataJson)
+                await adapter.write(pluginTargetFolderPath + "data.json", plugin.dataJson);
+            Logger("wrote:" + pluginTargetFolderPath + "data.json", LOG_LEVEL.NOTICE);
+            if (stat) {
+                // @ts-ignore
+                await this.app.plugins.loadPlugin(plugin.manifest.id);
+                Logger(`Load plugin:${plugin.manifest.id}`, LOG_LEVEL.NOTICE);
+            }
+        });
+    }
+
+    async applyPlugin(plugin: PluginDataEntry) {
+        await runWithLock("plugin-" + plugin.manifest.id, false, async () => {
+            // @ts-ignore
+            const stat = this.app.plugins.enabledPlugins.has(plugin.manifest.id) == true;
+            if (stat) {
+                // @ts-ignore
+                await this.app.plugins.unloadPlugin(plugin.manifest.id);
+                Logger(`Unload plugin:${plugin.manifest.id}`, LOG_LEVEL.NOTICE);
+            }
+
+            const pluginTargetFolderPath = normalizePath(plugin.manifest.dir) + "/";
+            const adapter = this.app.vault.adapter;
+            if ((await adapter.exists(pluginTargetFolderPath)) === false) {
+                await adapter.mkdir(pluginTargetFolderPath);
+            }
+            await adapter.write(pluginTargetFolderPath + "main.js", plugin.mainJs);
+            await adapter.write(pluginTargetFolderPath + "manifest.json", plugin.manifestJson);
+            if (plugin.styleCss)
+                await adapter.write(pluginTargetFolderPath + "styles.css", plugin.styleCss);
+            if (stat) {
+                // @ts-ignore
+                await this.app.plugins.loadPlugin(plugin.manifest.id);
+                Logger(`Load plugin:${plugin.manifest.id}`, LOG_LEVEL.NOTICE);
+            }
+        });
+    }
+}

src/CmdSetupLiveSync.ts

@@ -0,0 +1,192 @@
+import { EntryDoc, ObsidianLiveSyncSettings, LOG_LEVEL, DEFAULT_SETTINGS } from "./lib/src/types";
+import { configURIBase } from "./types";
+import { Logger } from "./lib/src/logger";
+import { PouchDB } from "./lib/src/pouchdb-browser.js";
+import { askSelectString, askYesNo, askString } from "./utils";
+import { decrypt, encrypt } from "./lib/src/e2ee_v2";
+import { LiveSyncCommands } from "./LiveSyncCommands";
+
+export class SetupLiveSync extends LiveSyncCommands {
+    onunload() { }
+    onload(): void | Promise<void> {
+        this.plugin.registerObsidianProtocolHandler("setuplivesync", async (conf: any) => await this.setupWizard(conf.settings));
+
+        this.plugin.addCommand({
+            id: "livesync-copysetupuri",
+            name: "Copy the setup URI",
+            callback: this.command_copySetupURI.bind(this),
+        });
+
+        this.plugin.addCommand({
+            id: "livesync-copysetupurifull",
+            name: "Copy the setup URI (Full)",
+            callback: this.command_copySetupURIFull.bind(this),
+        });
+
+        this.plugin.addCommand({
+            id: "livesync-opensetupuri",
+            name: "Open the setup URI",
+            callback: this.command_openSetupURI.bind(this),
+        });
+    }
+    onInitializeDatabase(showNotice: boolean) { }
+    beforeReplicate(showNotice: boolean) { }
+    onResume() { }
+    parseReplicationResultItem(docs: PouchDB.Core.ExistingDocument<EntryDoc>): boolean | Promise<boolean> {
+        return false;
+    }
+    async realizeSettingSyncMode() { }
+
+    async command_copySetupURI() {
+        const encryptingPassphrase = await askString(this.app, "Encrypt your settings", "The passphrase to encrypt the setup URI", "");
+        if (encryptingPassphrase === false)
+            return;
+        const setting = { ...this.settings, configPassphraseStore: "", encryptedCouchDBConnection: "", encryptedPassphrase: "" };
+        const keys = Object.keys(setting) as (keyof ObsidianLiveSyncSettings)[];
+        for (const k of keys) {
+            if (JSON.stringify(k in setting ? setting[k] : "") == JSON.stringify(k in DEFAULT_SETTINGS ? DEFAULT_SETTINGS[k] : "*")) {
+                delete setting[k];
+            }
+        }
+        const encryptedSetting = encodeURIComponent(await encrypt(JSON.stringify(setting), encryptingPassphrase, false));
+        const uri = `${configURIBase}${encryptedSetting}`;
+        await navigator.clipboard.writeText(uri);
+        Logger("Setup URI copied to clipboard", LOG_LEVEL.NOTICE);
+    }
+    async command_copySetupURIFull() {
+        const encryptingPassphrase = await askString(this.app, "Encrypt your settings", "The passphrase to encrypt the setup URI", "");
+        if (encryptingPassphrase === false)
+            return;
+        const setting = { ...this.settings, configPassphraseStore: "", encryptedCouchDBConnection: "", encryptedPassphrase: "" };
+        const encryptedSetting = encodeURIComponent(await encrypt(JSON.stringify(setting), encryptingPassphrase, false));
+        const uri = `${configURIBase}${encryptedSetting}`;
+        await navigator.clipboard.writeText(uri);
+        Logger("Setup URI copied to clipboard", LOG_LEVEL.NOTICE);
+    }
+    async command_openSetupURI() {
+        const setupURI = await askString(this.app, "Easy setup", "Set up URI", `${configURIBase}aaaaa`);
+        if (setupURI === false)
+            return;
+        if (!setupURI.startsWith(`${configURIBase}`)) {
+            Logger("Set up URI looks wrong.", LOG_LEVEL.NOTICE);
+            return;
+        }
+        const config = decodeURIComponent(setupURI.substring(configURIBase.length));
+        console.dir(config);
+        await this.setupWizard(config);
+    }
+    async setupWizard(confString: string) {
+        try {
+            const oldConf = JSON.parse(JSON.stringify(this.settings));
+            const encryptingPassphrase = await askString(this.app, "Passphrase", "The passphrase to decrypt your setup URI", "");
+            if (encryptingPassphrase === false)
+                return;
+            const newConf = await JSON.parse(await decrypt(confString, encryptingPassphrase, false));
+            if (newConf) {
+                const result = await askYesNo(this.app, "Importing LiveSync's conf, OK?");
+                if (result == "yes") {
+                    const newSettingW = Object.assign({}, DEFAULT_SETTINGS, newConf) as ObsidianLiveSyncSettings;
+                    this.plugin.replicator.closeReplication();
+                    this.settings.suspendFileWatching = true;
+                    console.dir(newSettingW);
+                    // Back into the default method once.
+                    newSettingW.configPassphraseStore = "";
+                    newSettingW.encryptedPassphrase = "";
+                    newSettingW.encryptedCouchDBConnection = "";
+                    const setupJustImport = "Just import setting";
+                    const setupAsNew = "Set it up as secondary or subsequent device";
+                    const setupAgain = "Reconfigure and reconstitute the data";
+                    const setupManually = "Leave everything to me";
+
+                    const setupType = await askSelectString(this.app, "How would you like to set it up?", [setupAsNew, setupAgain, setupJustImport, setupManually]);
+                    if (setupType == setupJustImport) {
+                        this.plugin.settings = newSettingW;
+                        this.plugin.usedPassphrase = "";
+                        await this.plugin.saveSettings();
+                    } else if (setupType == setupAsNew) {
+                        this.plugin.settings = newSettingW;
+                        this.plugin.usedPassphrase = "";
+                        await this.plugin.saveSettings();
+                        await this.plugin.resetLocalDatabase();
+                        await this.plugin.localDatabase.initializeDatabase();
+                        await this.plugin.markRemoteResolved();
+                        await this.plugin.replicate(true);
+                    } else if (setupType == setupAgain) {
+                        const confirm = "I know this operation will rebuild all my databases with files on this device, and files that are on the remote database and I didn't synchronize to any other devices will be lost and want to proceed indeed.";
+                        if (await askSelectString(this.app, "Do you really want to do this?", ["Cancel", confirm]) != confirm) {
+                            return;
+                        }
+                        this.plugin.settings = newSettingW;
+                        this.plugin.usedPassphrase = "";
+                        await this.plugin.saveSettings();
+                        await this.plugin.resetLocalDatabase();
+                        await this.plugin.localDatabase.initializeDatabase();
+                        await this.plugin.initializeDatabase(true);
+                        await this.plugin.tryResetRemoteDatabase();
+                        await this.plugin.markRemoteLocked();
+                        await this.plugin.markRemoteResolved();
+                        await this.plugin.replicate(true);
+
+                    } else if (setupType == setupManually) {
+                        const keepLocalDB = await askYesNo(this.app, "Keep local DB?");
+                        const keepRemoteDB = await askYesNo(this.app, "Keep remote DB?");
+                        if (keepLocalDB == "yes" && keepRemoteDB == "yes") {
+                            // nothing to do. so peaceful.
+                            this.plugin.settings = newSettingW;
+                            this.plugin.usedPassphrase = "";
+                            await this.plugin.saveSettings();
+                            const replicate = await askYesNo(this.app, "Unlock and replicate?");
+                            if (replicate == "yes") {
+                                await this.plugin.replicate(true);
+                                await this.plugin.markRemoteUnlocked();
+                            }
+                            Logger("Configuration loaded.", LOG_LEVEL.NOTICE);
+                            return;
+                        }
+                        if (keepLocalDB == "no" && keepRemoteDB == "no") {
+                            const reset = await askYesNo(this.app, "Drop everything?");
+                            if (reset != "yes") {
+                                Logger("Cancelled", LOG_LEVEL.NOTICE);
+                                this.plugin.settings = oldConf;
+                                return;
+                            }
+                        }
+                        let initDB;
+                        this.plugin.settings = newSettingW;
+                        this.plugin.usedPassphrase = "";
+                        await this.plugin.saveSettings();
+                        if (keepLocalDB == "no") {
+                            await this.plugin.resetLocalDatabase();
+                            await this.plugin.localDatabase.initializeDatabase();
+                            const rebuild = await askYesNo(this.app, "Rebuild the database?");
+                            if (rebuild == "yes") {
+                                initDB = this.plugin.initializeDatabase(true);
+                            } else {
+                                await this.plugin.markRemoteResolved();
+                            }
+                        }
+                        if (keepRemoteDB == "no") {
+                            await this.plugin.tryResetRemoteDatabase();
+                            await this.plugin.markRemoteLocked();
+                        }
+                        if (keepLocalDB == "no" || keepRemoteDB == "no") {
+                            const replicate = await askYesNo(this.app, "Replicate once?");
+                            if (replicate == "yes") {
+                                if (initDB != null) {
+                                    await initDB;
+                                }
+                                await this.plugin.replicate(true);
+                            }
+                        }
+                    }
+                }
+
+                Logger("Configuration loaded.", LOG_LEVEL.NOTICE);
+            } else {
+                Logger("Cancelled.", LOG_LEVEL.NOTICE);
+            }
+        } catch (ex) {
+            Logger("Couldn't parse or decrypt configuration uri.", LOG_LEVEL.NOTICE);
+        }
+    }
+}

src/ConflictResolveModal.ts

@@ -1,4 +1,4 @@
-import { App, Modal } from "obsidian";
+import { App, Modal } from "./deps";
 import { DIFF_DELETE, DIFF_EQUAL, DIFF_INSERT } from "diff-match-patch";
 import { diff_result } from "./lib/src/types";
 import { escapeStringToHTML } from "./lib/src/strbin";

src/DocumentHistoryModal.ts

@@ -1,12 +1,13 @@
-import { TFile, Modal, App } from "obsidian";
-import { isValidPath, path2id } from "./utils";
+import { TFile, Modal, App } from "./deps";
+import { getPathFromTFile, isValidPath } from "./utils";
 import { base64ToArrayBuffer, base64ToString, escapeStringToHTML } from "./lib/src/strbin";
 import ObsidianLiveSyncPlugin from "./main";
 import { DIFF_DELETE, DIFF_EQUAL, DIFF_INSERT, diff_match_patch } from "diff-match-patch";
-import { LoadedEntry, LOG_LEVEL } from "./lib/src/types";
+import { DocumentID, FilePathWithPrefix, LoadedEntry, LOG_LEVEL } from "./lib/src/types";
 import { Logger } from "./lib/src/logger";
 import { isErrorOfMissingDoc } from "./lib/src/utils_couchdb";
 import { getDocData } from "./lib/src/utils";
+import { stripPrefix } from "./lib/src/path";
 
 export class DocumentHistoryModal extends Modal {
     plugin: ObsidianLiveSyncPlugin;
@@ -15,26 +16,35 @@ export class DocumentHistoryModal extends Modal {
     info: HTMLDivElement;
     fileInfo: HTMLDivElement;
     showDiff = false;
+    id: DocumentID;
 
-    file: string;
+    file: FilePathWithPrefix;
 
     revs_info: PouchDB.Core.RevisionInfo[] = [];
     currentDoc: LoadedEntry;
     currentText = "";
     currentDeleted = false;
 
-    constructor(app: App, plugin: ObsidianLiveSyncPlugin, file: TFile | string) {
+    constructor(app: App, plugin: ObsidianLiveSyncPlugin, file: TFile | FilePathWithPrefix, id: DocumentID) {
         super(app);
         this.plugin = plugin;
-        this.file = (file instanceof TFile) ? file.path : file;
+        this.file = (file instanceof TFile) ? getPathFromTFile(file) : file;
+        this.id = id;
+        if (!file) {
+            this.file = this.plugin.id2path(id, null);
+        }
         if (localStorage.getItem("ols-history-highlightdiff") == "1") {
             this.showDiff = true;
         }
     }
+
     async loadFile() {
+        if (!this.id) {
+            this.id = await this.plugin.path2id(this.file);
+        }
         const db = this.plugin.localDatabase;
         try {
-            const w = await db.localDatabase.get(path2id(this.file), { revs_info: true });
+            const w = await db.localDatabase.get(this.id, { revs_info: true });
             this.revs_info = w._revs_info.filter((e) => e?.status == "available");
             this.range.max = `${this.revs_info.length - 1}`;
             this.range.value = this.range.max;
@@ -47,6 +57,9 @@ export class DocumentHistoryModal extends Modal {
                 this.range.disabled = true;
                 this.showDiff
                 this.contentView.setText(`History of this file was not recorded.`);
+            } else {
+                this.contentView.setText(`Error occurred.`);
+                Logger(ex, LOG_LEVEL.VERBOSE);
             }
         }
     }
@@ -55,7 +68,7 @@ export class DocumentHistoryModal extends Modal {
         const db = this.plugin.localDatabase;
         const index = this.revs_info.length - 1 - (this.range.value as any) / 1;
         const rev = this.revs_info[index];
-        const w = await db.getDBEntry(path2id(this.file), { rev: rev.rev }, false, false, true);
+        const w = await db.getDBEntry(this.file, { rev: rev.rev }, false, false, true);
         this.currentText = "";
         this.currentDeleted = false;
         if (w === false) {
@@ -73,7 +86,7 @@ export class DocumentHistoryModal extends Modal {
                 const prevRevIdx = this.revs_info.length - 1 - ((this.range.value as any) / 1 - 1);
                 if (prevRevIdx >= 0 && prevRevIdx < this.revs_info.length) {
                     const oldRev = this.revs_info[prevRevIdx].rev;
-                    const w2 = await db.getDBEntry(path2id(this.file), { rev: oldRev }, false, false, true);
+                    const w2 = await db.getDBEntry(this.file, { rev: oldRev }, false, false, true);
                     if (w2 != false) {
                         const dmp = new diff_match_patch();
                         const w2data = w2.datatype == "plain" ? getDocData(w2.data) : base64ToString(w2.data);
@@ -102,7 +115,6 @@ export class DocumentHistoryModal extends Modal {
                 result = escapeStringToHTML(w1data);
             }
             this.contentView.innerHTML = (this.currentDeleted ? "(At this revision, the file has been deleted)\n" : "") + result;
-
         }
     }
 
@@ -173,7 +185,8 @@ export class DocumentHistoryModal extends Modal {
         buttons.createEl("button", { text: "Back to this revision" }, (e) => {
             e.addClass("mod-cta");
             e.addEventListener("click", async () => {
-                const pathToWrite = this.file.startsWith("i:") ? this.file.substring("i:".length) : this.file;
+                // const pathToWrite = this.plugin.id2path(this.id, true);
+                const pathToWrite = stripPrefix(this.file);
                 if (!isValidPath(pathToWrite)) {
                     Logger("Path is not valid to write content.", LOG_LEVEL.INFO);
                 }

src/JsonResolveModal.ts

@@ -1,15 +1,15 @@
-import { App, Modal } from "obsidian";
-import { LoadedEntry } from "./lib/src/types";
+import { App, Modal } from "./deps";
+import { FilePath, LoadedEntry } from "./lib/src/types";
 import JsonResolvePane from "./JsonResolvePane.svelte";
 
 export class JsonResolveModal extends Modal {
     // result: Array<[number, string]>;
-    filename: string;
+    filename: FilePath;
     callback: (keepRev: string, mergedStr?: string) => Promise<void>;
     docs: LoadedEntry[];
     component: JsonResolvePane;
 
-    constructor(app: App, filename: string, docs: LoadedEntry[], callback: (keepRev: string, mergedStr?: string) => Promise<void>) {
+    constructor(app: App, filename: FilePath, docs: LoadedEntry[], callback: (keepRev: string, mergedStr?: string) => Promise<void>) {
         super(app);
         this.callback = callback;
         this.filename = filename;
@@ -31,6 +31,7 @@ export class JsonResolveModal extends Modal {
                 target: contentEl,
                 props: {
                     docs: this.docs,
+                    filename: this.filename,
                     callback: (keepRev, mergedStr) => this.UICallback(keepRev, mergedStr),
                 },
             });

src/JsonResolvePane.svelte

@@ -1,14 +1,15 @@
 <script lang="ts">
     import { Diff, DIFF_DELETE, DIFF_INSERT, diff_match_patch } from "diff-match-patch";
-    import type { LoadedEntry } from "./lib/src/types";
+    import type { FilePath, LoadedEntry } from "./lib/src/types";
     import { base64ToString } from "./lib/src/strbin";
     import { getDocData } from "./lib/src/utils";
-    import { id2path, mergeObject } from "./utils";
+    import { mergeObject } from "./utils";
 
     export let docs: LoadedEntry[] = [];
     export let callback: (keepRev: string, mergedStr?: string) => Promise<void> = async (_, __) => {
         Promise.resolve();
     };
+    export let filename: FilePath = "" as FilePath;
 
     let docA: LoadedEntry = undefined;
     let docB: LoadedEntry = undefined;
@@ -93,7 +94,6 @@
         diffs = getJsonDiff(objA, selectedObj);
         console.dir(selectedObj);
     }
-    $: filename = id2path(docA?._id ?? "");
 </script>
 
 <h1>Conflicted settings</h1>

src/LiveSyncCommands.ts

@@ -0,0 +1,37 @@
+import { AnyEntry, DocumentID, EntryDoc, EntryHasPath, FilePath, FilePathWithPrefix } from "./lib/src/types";
+import { PouchDB } from "./lib/src/pouchdb-browser.js";
+import type ObsidianLiveSyncPlugin from "./main";
+
+
+export abstract class LiveSyncCommands {
+    plugin: ObsidianLiveSyncPlugin;
+    get app() {
+        return this.plugin.app;
+    }
+    get settings() {
+        return this.plugin.settings;
+    }
+    get localDatabase() {
+        return this.plugin.localDatabase;
+    }
+    id2path(id: DocumentID, entry?: EntryHasPath, stripPrefix?: boolean): FilePathWithPrefix {
+        return this.plugin.id2path(id, entry, stripPrefix);
+    }
+    async path2id(filename: FilePathWithPrefix | FilePath, prefix?: string): Promise<DocumentID> {
+        return await this.plugin.path2id(filename, prefix);
+    }
+    getPath(entry: AnyEntry): FilePathWithPrefix {
+        return this.plugin.getPath(entry);
+    }
+
+    constructor(plugin: ObsidianLiveSyncPlugin) {
+        this.plugin = plugin;
+    }
+    abstract onunload(): void;
+    abstract onload(): void | Promise<void>;
+    abstract onInitializeDatabase(showNotice: boolean): void | Promise<void>;
+    abstract beforeReplicate(showNotice: boolean): void | Promise<void>;
+    abstract onResume(): void | Promise<void>;
+    abstract parseReplicationResultItem(docs: PouchDB.Core.ExistingDocument<EntryDoc>): Promise<boolean> | boolean;
+    abstract realizeSettingSyncMode(): Promise<void>;
+}

src/LocalPouchDB.ts

@@ -1,178 +0,0 @@
-import { requestUrl, RequestUrlParam, RequestUrlResponse } from "obsidian";
-import { KeyValueDatabase, OpenKeyValueDatabase } from "./KeyValueDB.js";
-import { LocalPouchDBBase } from "./lib/src/LocalPouchDBBase.js";
-import { Logger } from "./lib/src/logger.js";
-import { PouchDB } from "./lib/src/pouchdb-browser.js";
-import { EntryDoc, LOG_LEVEL, ObsidianLiveSyncSettings } from "./lib/src/types.js";
-import { enableEncryption } from "./lib/src/utils_couchdb.js";
-import { isCloudantURI, isValidRemoteCouchDBURI } from "./lib/src/utils_couchdb.js";
-import { id2path, path2id } from "./utils.js";
-
-export class LocalPouchDB extends LocalPouchDBBase {
-
-    kvDB: KeyValueDatabase;
-    settings: ObsidianLiveSyncSettings;
-    id2path(filename: string): string {
-        return id2path(filename);
-    }
-    path2id(filename: string): string {
-        return path2id(filename);
-    }
-    CreatePouchDBInstance<T>(name?: string, options?: PouchDB.Configuration.DatabaseConfiguration): PouchDB.Database<T> {
-        if (this.settings.useIndexedDBAdapter) {
-            options.adapter = "indexeddb";
-            return new PouchDB(name + "-indexeddb", options);
-        }
-        return new PouchDB(name, options);
-    }
-    beforeOnUnload(): void {
-        this.kvDB.close();
-    }
-    onClose(): void {
-        this.kvDB.close();
-    }
-    async onInitializeDatabase(): Promise<void> {
-        this.kvDB = await OpenKeyValueDatabase(this.dbname + "-livesync-kv");
-    }
-    async onResetDatabase(): Promise<void> {
-        await this.kvDB.destroy();
-    }
-
-    last_successful_post = false;
-    getLastPostFailedBySize() {
-        return !this.last_successful_post;
-    }
-    async fetchByAPI(request: RequestUrlParam): Promise<RequestUrlResponse> {
-        const ret = await requestUrl(request);
-        if (ret.status - (ret.status % 100) !== 200) {
-            const er: Error & { status?: number } = new Error(`Request Error:${ret.status}`);
-            if (ret.json) {
-                er.message = ret.json.reason;
-                er.name = `${ret.json.error ?? ""}:${ret.json.message ?? ""}`;
-            }
-            er.status = ret.status;
-            throw er;
-        }
-        return ret;
-    }
-
-
-    async connectRemoteCouchDB(uri: string, auth: { username: string; password: string }, disableRequestURI: boolean, passphrase: string | false, useDynamicIterationCount: boolean): Promise<string | { db: PouchDB.Database<EntryDoc>; info: PouchDB.Core.DatabaseInfo }> {
-        if (!isValidRemoteCouchDBURI(uri)) return "Remote URI is not valid";
-        if (uri.toLowerCase() != uri) return "Remote URI and database name could not contain capital letters.";
-        if (uri.indexOf(" ") !== -1) return "Remote URI and database name could not contain spaces.";
-        let authHeader = "";
-        if (auth.username && auth.password) {
-            const utf8str = String.fromCharCode.apply(null, new TextEncoder().encode(`${auth.username}:${auth.password}`));
-            const encoded = window.btoa(utf8str);
-            authHeader = "Basic " + encoded;
-        } else {
-            authHeader = "";
-        }
-        // const _this = this;
-
-        const conf: PouchDB.HttpAdapter.HttpAdapterConfiguration = {
-            adapter: "http",
-            auth,
-            fetch: async (url: string | Request, opts: RequestInit) => {
-                let size = "";
-                const localURL = url.toString().substring(uri.length);
-                const method = opts.method ?? "GET";
-                if (opts.body) {
-                    const opts_length = opts.body.toString().length;
-                    if (opts_length > 1000 * 1000 * 10) {
-                        // over 10MB
-                        if (isCloudantURI(uri)) {
-                            this.last_successful_post = false;
-                            Logger("This request should fail on IBM Cloudant.", LOG_LEVEL.VERBOSE);
-                            throw new Error("This request should fail on IBM Cloudant.");
-                        }
-                    }
-                    size = ` (${opts_length})`;
-                }
-
-                if (!disableRequestURI && typeof url == "string" && typeof (opts.body ?? "") == "string") {
-                    const body = opts.body as string;
-
-                    const transformedHeaders = { ...(opts.headers as Record<string, string>) };
-                    if (authHeader != "") transformedHeaders["authorization"] = authHeader;
-                    delete transformedHeaders["host"];
-                    delete transformedHeaders["Host"];
-                    delete transformedHeaders["content-length"];
-                    delete transformedHeaders["Content-Length"];
-                    const requestParam: RequestUrlParam = {
-                        url: url as string,
-                        method: opts.method,
-                        body: body,
-                        headers: transformedHeaders,
-                        contentType: "application/json",
-                        // contentType: opts.headers,
-                    };
-
-                    try {
-                        const r = await this.fetchByAPI(requestParam);
-                        if (method == "POST" || method == "PUT") {
-                            this.last_successful_post = r.status - (r.status % 100) == 200;
-                        } else {
-                            this.last_successful_post = true;
-                        }
-                        Logger(`HTTP:${method}${size} to:${localURL} -> ${r.status}`, LOG_LEVEL.DEBUG);
-
-                        return new Response(r.arrayBuffer, {
-                            headers: r.headers,
-                            status: r.status,
-                            statusText: `${r.status}`,
-                        });
-                    } catch (ex) {
-                        Logger(`HTTP:${method}${size} to:${localURL} -> failed`, LOG_LEVEL.VERBOSE);
-                        // limit only in bulk_docs.
-                        if (url.toString().indexOf("_bulk_docs") !== -1) {
-                            this.last_successful_post = false;
-                        }
-                        Logger(ex);
-                        throw ex;
-                    }
-                }
-
-                // -old implementation
-
-                try {
-                    const response: Response = await fetch(url, opts);
-                    if (method == "POST" || method == "PUT") {
-                        this.last_successful_post = response.ok;
-                    } else {
-                        this.last_successful_post = true;
-                    }
-                    Logger(`HTTP:${method}${size} to:${localURL} -> ${response.status}`, LOG_LEVEL.DEBUG);
-                    return response;
-                } catch (ex) {
-                    Logger(`HTTP:${method}${size} to:${localURL} -> failed`, LOG_LEVEL.VERBOSE);
-                    // limit only in bulk_docs.
-                    if (url.toString().indexOf("_bulk_docs") !== -1) {
-                        this.last_successful_post = false;
-                    }
-                    Logger(ex);
-                    throw ex;
-                }
-                // return await fetch(url, opts);
-            },
-        };
-
-        const db: PouchDB.Database<EntryDoc> = new PouchDB<EntryDoc>(uri, conf);
-        if (passphrase !== "false" && typeof passphrase === "string") {
-            enableEncryption(db, passphrase, useDynamicIterationCount);
-        }
-        try {
-            const info = await db.info();
-            return { db: db, info: info };
-        } catch (ex) {
-            let msg = `${ex.name}:${ex.message}`;
-            if (ex.name == "TypeError" && ex.message == "Failed to fetch") {
-                msg += "\n**Note** This error caused by many reasons. The only sure thing is you didn't touch the server.\nTo check details, open inspector.";
-            }
-            Logger(ex, LOG_LEVEL.VERBOSE);
-            return msg;
-        }
-    }
-
-}

src/LogDisplayModal.ts

@@ -1,4 +1,4 @@
-import { App, Modal } from "obsidian";
+import { App, Modal } from "./deps";
 import { logMessageStore } from "./lib/src/stores";
 import { escapeStringToHTML } from "./lib/src/strbin";
 import ObsidianLiveSyncPlugin from "./main";

src/ObsidianLiveSyncSettingTab.ts

@@ -1,6 +1,5 @@
-import { App, PluginSettingTab, Setting, sanitizeHTMLToDom, RequestUrlParam, requestUrl, TextAreaComponent, MarkdownRenderer, stringifyYaml } from "obsidian";
+import { App, PluginSettingTab, Setting, sanitizeHTMLToDom, RequestUrlParam, requestUrl, TextAreaComponent, MarkdownRenderer, stringifyYaml } from "./deps";
 import { DEFAULT_SETTINGS, LOG_LEVEL, ObsidianLiveSyncSettings, ConfigPassphraseStore, RemoteDBSettings } from "./lib/src/types";
-import { path2id, id2path } from "./utils";
 import { delay } from "./lib/src/utils";
 import { Semaphore } from "./lib/src/semaphore";
 import { versionNumberString2Number } from "./lib/src/strbin";
@@ -28,13 +27,14 @@ const requestToCouchDB = async (baseUri: string, username: string, password: str
 };
 export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
     plugin: ObsidianLiveSyncPlugin;
+    selectedScreen = "";
 
     constructor(app: App, plugin: ObsidianLiveSyncPlugin) {
         super(app, plugin);
         this.plugin = plugin;
     }
     async testConnection(): Promise<void> {
-        const db = await this.plugin.localDatabase.connectRemoteCouchDBWithSetting(this.plugin.settings, this.plugin.localDatabase.isMobile);
+        const db = await this.plugin.replicator.connectRemoteCouchDBWithSetting(this.plugin.settings, this.plugin.isMobile);
         if (typeof db === "string") {
             this.plugin.addLog(`could not connect to ${this.plugin.settings.couchDB_URI} : ${this.plugin.settings.couchDB_DBNAME} \n(${db})`, LOG_LEVEL.NOTICE);
             return;
@@ -74,7 +74,7 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
 <label class='sls-setting-label c-40'><input type='radio' name='disp' value='40' class='sls-setting-tab' ><div class='sls-setting-menu-btn'>🔧</div></label>
 <label class='sls-setting-label c-50 wizardHidden'><input type='radio' name='disp' value='50' class='sls-setting-tab' ><div class='sls-setting-menu-btn'>🧰</div></label>
 <label class='sls-setting-label c-60 wizardHidden'><input type='radio' name='disp' value='60' class='sls-setting-tab' ><div class='sls-setting-menu-btn'>🔌</div></label>
-<label class='sls-setting-label c-70 wizardHidden'><input type='radio' name='disp' value='70' class='sls-setting-tab' ><div class='sls-setting-menu-btn'>🚑</div></label>
+<!-- <label class='sls-setting-label c-70 wizardHidden'><input type='radio' name='disp' value='70' class='sls-setting-tab' ><div class='sls-setting-menu-btn'>🚑</div></label>-->
         `;
         const menuTabs = w.querySelectorAll(".sls-setting-label");
         const changeDisplay = (screen: string) => {
@@ -87,12 +87,13 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
             }
             w.querySelectorAll(`.sls-setting-label`).forEach((element) => {
                 element.removeClass("selected");
-                (element.querySelector("input[type=radio]") as HTMLInputElement).checked = false;
+                (element.querySelector<HTMLInputElement>("input[type=radio]")).checked = false;
             });
             w.querySelectorAll(`.sls-setting-label.c-${screen}`).forEach((element) => {
                 element.addClass("selected");
-                (element.querySelector("input[type=radio]") as HTMLInputElement).checked = true;
+                (element.querySelector<HTMLInputElement>("input[type=radio]")).checked = true;
             });
+            this.selectedScreen = screen;
         };
         menuTabs.forEach((element) => {
             const e = element.querySelector(".sls-setting-tab");
@@ -139,8 +140,8 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
             if (this.plugin.settings.syncOnSave) return true;
             if (this.plugin.settings.syncOnStart) return true;
             if (this.plugin.settings.syncAfterMerge) return true;
-            if (this.plugin.localDatabase.syncStatus == "CONNECTED") return true;
-            if (this.plugin.localDatabase.syncStatus == "PAUSED") return true;
+            if (this.plugin.replicator.syncStatus == "CONNECTED") return true;
+            if (this.plugin.replicator.syncStatus == "PAUSED") return true;
             return false;
         };
         let inWizard = false;
@@ -152,7 +153,7 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
             .addButton((text) => {
                 text.setButtonText("Next").onClick(() => {
                     if (JSON.stringify(this.plugin.settings) != JSON.stringify(DEFAULT_SETTINGS)) {
-                        this.plugin.localDatabase.closeReplication();
+                        this.plugin.replicator.closeReplication();
                         this.plugin.settings = { ...DEFAULT_SETTINGS };
                         this.plugin.saveSettings();
 
@@ -177,7 +178,7 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
                     this.plugin.settings.syncOnStart = false;
                     this.plugin.settings.syncOnFileOpen = false;
                     this.plugin.settings.syncAfterMerge = false;
-                    this.plugin.localDatabase.closeReplication();
+                    this.plugin.replicator.closeReplication();
                     await this.plugin.saveSettings();
                     containerEl.addClass("isWizard");
                     applyDisplayEnabled();
@@ -305,11 +306,13 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
                         this.plugin.settings.encrypt = value;
                         passphraseSetting.setDisabled(!value);
                         dynamicIteration.setDisabled(!value);
+                        usePathObfuscationEl.setDisabled(!value);
                         await this.plugin.saveSettings();
                     } else {
                         encrypt = value;
                         passphraseSetting.setDisabled(!value);
                         dynamicIteration.setDisabled(!value);
+                        usePathObfuscationEl.setDisabled(!value);
                         await this.plugin.saveSettings();
                         markDirtyControl();
                     }
@@ -320,7 +323,8 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
         const markDirtyControl = () => {
             passphraseSetting.controlEl.toggleClass("sls-item-dirty", passphrase != this.plugin.settings.passphrase);
             e2e.controlEl.toggleClass("sls-item-dirty", encrypt != this.plugin.settings.encrypt);
-            dynamicIteration.controlEl.toggleClass("sls-item-dirty", useDynamicIterationCount != this.plugin.settings.useDynamicIterationCount)
+            dynamicIteration.controlEl.toggleClass("sls-item-dirty", useDynamicIterationCount != this.plugin.settings.useDynamicIterationCount);
+            usePathObfuscationEl.controlEl.toggleClass("sls-item-dirty", usePathObfuscation != this.plugin.settings.usePathObfuscation);
         }
 
         const passphraseSetting = new Setting(containerRemoteDatabaseEl)
@@ -343,6 +347,23 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
             });
         passphraseSetting.setDisabled(!encrypt);
 
+        let usePathObfuscation = this.plugin.settings.usePathObfuscation;
+        const usePathObfuscationEl = new Setting(containerRemoteDatabaseEl)
+            .setName("Path Obfuscation")
+            .setDesc("(Experimental) Obfuscate paths of files. If we configured, we should rebuild the database.")
+            .addToggle((toggle) =>
+                toggle.setValue(usePathObfuscation).onChange(async (value) => {
+                    if (inWizard) {
+                        this.plugin.settings.usePathObfuscation = value;
+                        await this.plugin.saveSettings();
+                    } else {
+                        usePathObfuscation = value;
+                        await this.plugin.saveSettings();
+                        markDirtyControl();
+                    }
+                })
+            );
+
         const dynamicIteration = new Setting(containerRemoteDatabaseEl)
             .setName("Use dynamic iteration count (experimental)")
             .setDesc("Balancing the encryption/decryption load against the length of the passphrase if toggled. (v0.17.5 or higher required)")
@@ -370,7 +391,7 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
                 useDynamicIterationCount: useDynamicIterationCount,
             };
             console.dir(settingForCheck);
-            const db = await this.plugin.localDatabase.connectRemoteCouchDBWithSetting(settingForCheck, this.plugin.localDatabase.isMobile);
+            const db = await this.plugin.replicator.connectRemoteCouchDBWithSetting(settingForCheck, this.plugin.isMobile);
             if (typeof db === "string") {
                 Logger("Could not connect to the database.", LOG_LEVEL.NOTICE);
                 return false;
@@ -408,6 +429,7 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
             this.plugin.settings.encrypt = encrypt;
             this.plugin.settings.passphrase = passphrase;
             this.plugin.settings.useDynamicIterationCount = useDynamicIterationCount;
+            this.plugin.settings.usePathObfuscation = usePathObfuscation;
 
             await this.plugin.saveSettings();
             markDirtyControl();
@@ -428,25 +450,45 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
             .setClass("wizardHidden")
             .addButton((button) =>
                 button
-                    .setButtonText("Apply")
-                    .setWarning()
-                    .setDisabled(false)
-                    .onClick(async () => {
-                        await applyEncryption(true);
-                    })
-            )
-            .addButton((button) =>
-                button
-                    .setButtonText("Apply w/o rebuilding")
+                    .setButtonText("Just apply")
                     .setWarning()
                     .setDisabled(false)
                     .onClick(async () => {
                         await applyEncryption(false);
                     })
+            )
+            .addButton((button) =>
+                button
+                    .setButtonText("Apply and Fetch")
+                    .setWarning()
+                    .setDisabled(false)
+                    .onClick(async () => {
+                        await rebuildDB("localOnly");
+                    })
+            )
+            .addButton((button) =>
+                button
+                    .setButtonText("Apply and Rebuild")
+                    .setWarning()
+                    .setDisabled(false)
+                    .onClick(async () => {
+                        await rebuildDB("rebuildBothByThisDevice");
+                    })
             );
 
 
         const rebuildDB = async (method: "localOnly" | "remoteOnly" | "rebuildBothByThisDevice") => {
+            if (encrypt && passphrase == "") {
+                Logger("If you enable encryption, you have to set the passphrase", LOG_LEVEL.NOTICE);
+                return;
+            }
+            if (encrypt && !(await testCrypt())) {
+                Logger("WARNING! Your device would not support encryption.", LOG_LEVEL.NOTICE);
+                return;
+            }
+            if (!encrypt) {
+                passphrase = "";
+            }
             this.plugin.settings.liveSync = false;
             this.plugin.settings.periodicReplication = false;
             this.plugin.settings.syncOnSave = false;
@@ -455,15 +497,24 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
             this.plugin.settings.syncAfterMerge = false;
             this.plugin.settings.syncInternalFiles = false;
             this.plugin.settings.usePluginSync = false;
+            this.plugin.settings.encrypt = encrypt;
+            this.plugin.settings.passphrase = passphrase;
+            this.plugin.settings.useDynamicIterationCount = useDynamicIterationCount;
+            this.plugin.settings.usePathObfuscation = usePathObfuscation;
             Logger("Hidden files and plugin synchronization have been temporarily disabled. Please enable them after the fetching, if you need them.", LOG_LEVEL.NOTICE)
             await this.plugin.saveSettings();
-
+            markDirtyControl();
             applyDisplayEnabled();
+            // @ts-ignore
+            this.plugin.app.setting.close()
             await delay(2000);
             if (method == "localOnly") {
                 await this.plugin.resetLocalDatabase();
+                await delay(1000);
                 await this.plugin.markRemoteResolved();
-                await this.plugin.replicate(true);
+                await this.plugin.openDatabase();
+                this.plugin.isReady = true;
+                await this.plugin.replicateAllFromServer(true);
             }
             if (method == "remoteOnly") {
                 await this.plugin.markRemoteLocked();
@@ -473,6 +524,7 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
             }
             if (method == "rebuildBothByThisDevice") {
                 await this.plugin.resetLocalDatabase();
+                await delay(1000);
                 await this.plugin.initializeDatabase(true);
                 await this.plugin.markRemoteLocked();
                 await this.plugin.tryResetRemoteDatabase();
@@ -914,7 +966,7 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
             });
             c.addClass("op-warn");
         }
-
+        containerSyncSettingEl.createEl("h3", { text: "Synchronization Methods" });
         const syncLive: Setting[] = [];
         const syncNonLive: Setting[] = [];
         syncLive.push(
@@ -967,6 +1019,7 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
                     text.inputEl.setAttribute("type", "number");
                 }),
 
+
             new Setting(containerSyncSettingEl)
                 .setName("Sync on Save")
                 .setDesc("When you save file, sync automatically")
@@ -1008,7 +1061,7 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
                     })
                 ),
         );
-
+        containerSyncSettingEl.createEl("h3", { text: "File deletion" });
         new Setting(containerSyncSettingEl)
             .setName("Use Trash for deleted files")
             .setDesc("Do not delete files that are deleted in remote, just move to trash.")
@@ -1029,6 +1082,7 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
                 })
             );
 
+        containerSyncSettingEl.createEl("h3", { text: "Conflict resolution" });
         new Setting(containerSyncSettingEl)
             .setName("Use newer file if conflicted (beta)")
             .setDesc("Resolve conflicts by newer files automatically.")
@@ -1067,14 +1121,63 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
                 })
             );
 
-        new Setting(containerSyncSettingEl)
-            .setName("Sync hidden files")
-            .addToggle((toggle) =>
-                toggle.setValue(this.plugin.settings.syncInternalFiles).onChange(async (value) => {
-                    this.plugin.settings.syncInternalFiles = value;
-                    await this.plugin.saveSettings();
+        containerSyncSettingEl.createEl("h3", { text: "Hidden files" });
+        const LABEL_ENABLED = "🔁 : Enabled";
+        const LABEL_DISABLED = "⏹️ : Disabled"
+
+        const hiddenFileSyncSetting = new Setting(containerSyncSettingEl)
+            .setName("Hidden file synchronization")
+        const hiddenFileSyncSettingEl = hiddenFileSyncSetting.settingEl
+        const hiddenFileSyncSettingDiv = hiddenFileSyncSettingEl.createDiv("");
+        hiddenFileSyncSettingDiv.innerText = this.plugin.settings.syncInternalFiles ? LABEL_ENABLED : LABEL_DISABLED;
+
+        if (this.plugin.settings.syncInternalFiles) {
+            new Setting(containerSyncSettingEl)
+                .setName("Disable Hidden files sync")
+                .addButton((button) => {
+                    button.setButtonText("Disable")
+                        .onClick(async () => {
+                            this.plugin.settings.syncInternalFiles = false;
+                            await this.plugin.saveSettings();
+                            this.display();
+                        })
                 })
-            );
+        } else {
+
+            new Setting(containerSyncSettingEl)
+                .setName("Enable Hidden files sync")
+                .addButton((button) => {
+                    button.setButtonText("Merge")
+                        .onClick(async () => {
+                            this.plugin.settings.syncInternalFiles = true;
+                            this.display();
+                            await this.plugin.addOnHiddenFileSync.syncInternalFilesAndDatabase("safe", true);
+                            await this.plugin.saveSettings();
+                            this.display();
+                        })
+                })
+                .addButton((button) => {
+                    button.setButtonText("Fetch")
+                        .onClick(async () => {
+                            this.plugin.settings.syncInternalFiles = true;
+                            this.display();
+                            await this.plugin.addOnHiddenFileSync.syncInternalFilesAndDatabase("pullForce", true);
+                            await this.plugin.saveSettings();
+                            Logger(`Restarting the app is strongly recommended!`, LOG_LEVEL.NOTICE);
+                            this.display();
+                        })
+                })
+                .addButton((button) => {
+                    button.setButtonText("Overwrite")
+                        .onClick(async () => {
+                            this.plugin.settings.syncInternalFiles = true;
+                            this.display();
+                            await this.plugin.addOnHiddenFileSync.syncInternalFilesAndDatabase("pushForce", true);
+                            await this.plugin.saveSettings();
+                            this.display();
+                        })
+                });
+        }
 
         new Setting(containerSyncSettingEl)
             .setName("Scan for hidden files before replication")
@@ -1139,31 +1242,9 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
                     })
             })
 
-        new Setting(containerSyncSettingEl)
-            .setName("Touch hidden files")
-            .setDesc("Update the modified time of all hidden files to the current time.")
-            .addButton((button) =>
-                button
-                    .setButtonText("Touch")
-                    .setWarning()
-                    .setDisabled(false)
-                    .onClick(async () => {
-                        const filesAll = await this.plugin.scanInternalFiles();
-                        const targetFiles = await this.plugin.filterTargetFiles(filesAll);
-                        const now = Date.now();
-                        const newFiles = targetFiles.map(e => ({ ...e, mtime: now }));
-                        let i = 0;
-                        const maxFiles = newFiles.length;
-                        for (const file of newFiles) {
-                            i++;
-                            Logger(`Touched:${file.path} (${i}/${maxFiles})`, LOG_LEVEL.NOTICE, "touch-files");
-                            await this.plugin.applyMTimeToFile(file);
-                        }
-                    })
-            )
 
         containerSyncSettingEl.createEl("h3", {
-            text: sanitizeHTMLToDom(`Experimental`),
+            text: sanitizeHTMLToDom(`Synchronization filters`),
         });
         new Setting(containerSyncSettingEl)
             .setName("Regular expression to ignore files")
@@ -1211,7 +1292,7 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
                 return text;
             }
             );
-
+        containerSyncSettingEl.createEl("h3", { text: "Efficiency" });
         new Setting(containerSyncSettingEl)
             .setName("Chunk size")
             .setDesc("Customize chunk size for binary files (0.1MBytes). This cannot be increased when using IBM Cloudant.")
@@ -1230,7 +1311,7 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
             });
 
         new Setting(containerSyncSettingEl)
-            .setName("Read chunks online.")
+            .setName("Read chunks online")
             .setDesc("If this option is enabled, LiveSync reads chunks online directly instead of replicating them locally. Increasing Custom chunk size is recommended.")
             .addToggle((toggle) => {
                 toggle
@@ -1240,8 +1321,7 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
                         await this.plugin.saveSettings();
                     })
                 return toggle;
-            }
-            );
+            });
         containerSyncSettingEl.createEl("h3", {
             text: sanitizeHTMLToDom(`Advanced settings`),
         });
@@ -1392,28 +1472,50 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
                             Logger("Select any preset.", LOG_LEVEL.NOTICE);
                             return;
                         }
-                        this.plugin.settings.batchSave = false;
-                        this.plugin.settings.liveSync = false;
-                        this.plugin.settings.periodicReplication = false;
-                        this.plugin.settings.syncOnSave = false;
-                        this.plugin.settings.syncOnStart = false;
-                        this.plugin.settings.syncOnFileOpen = false;
-                        this.plugin.settings.syncAfterMerge = false;
+                        const presetAllDisabled = {
+                            batchSave: false,
+                            liveSync: false,
+                            periodicReplication: false,
+                            syncOnSave: false,
+                            syncOnStart: false,
+                            syncOnFileOpen: false,
+                            syncAfterMerge: false,
+                        } as Partial<ObsidianLiveSyncSettings>;
+                        const presetLiveSync = {
+                            ...presetAllDisabled,
+                            liveSync: true
+                        } as Partial<ObsidianLiveSyncSettings>;
+                        const presetPeriodic = {
+                            ...presetAllDisabled,
+                            batchSave: true,
+                            periodicReplication: true,
+                            syncOnSave: false,
+                            syncOnStart: true,
+                            syncOnFileOpen: true,
+                            syncAfterMerge: true,
+                        } as Partial<ObsidianLiveSyncSettings>;
+
                         if (currentPreset == "LIVESYNC") {
-                            this.plugin.settings.liveSync = true;
+                            this.plugin.settings = {
+                                ...this.plugin.settings,
+                                ...presetLiveSync
+                            }
                             Logger("Synchronization setting configured as LiveSync.", LOG_LEVEL.NOTICE);
                         } else if (currentPreset == "PERIODIC") {
-                            this.plugin.settings.batchSave = true;
-                            this.plugin.settings.periodicReplication = true;
-                            this.plugin.settings.syncOnSave = false;
-                            this.plugin.settings.syncOnStart = true;
-                            this.plugin.settings.syncOnFileOpen = true;
-                            this.plugin.settings.syncAfterMerge = true;
+                            this.plugin.settings = {
+                                ...this.plugin.settings,
+                                ...presetPeriodic
+                            }
                             Logger("Synchronization setting configured as Periodic sync with batch database update.", LOG_LEVEL.NOTICE);
                         } else {
                             Logger("All synchronization disabled.", LOG_LEVEL.NOTICE);
+                            this.plugin.settings = {
+                                ...this.plugin.settings,
+                                ...presetAllDisabled
+                            }
                         }
                         this.plugin.saveSettings();
+                        this.display();
                         await this.plugin.realizeSettingSyncMode();
                         if (inWizard) {
                             // @ts-ignore
@@ -1432,8 +1534,6 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
                             // @ts-ignore
                             this.plugin.app.commands.executeCommandById("obsidian-livesync:livesync-copysetupuri")
                         }
-
-
                     })
             );
 
@@ -1530,7 +1630,7 @@ ${stringifyYaml(pluginConfig)}`;
                     })
             );
 
-        if (this.plugin.localDatabase.remoteLockedAndDeviceNotAccepted) {
+        if (this.plugin.replicator.remoteLockedAndDeviceNotAccepted) {
             const c = containerHatchEl.createEl("div", {
                 text: "To prevent unwanted vault corruption, the remote database has been locked for synchronization, and this device was not marked as 'resolved'. it caused by some operations like this. re-initialized. Local database initialization should be required. please back your vault up, reset local database, and press 'Mark this device as resolved'. ",
             });
@@ -1543,7 +1643,7 @@ ${stringifyYaml(pluginConfig)}`;
             });
             c.addClass("op-warn");
         } else {
-            if (this.plugin.localDatabase.remoteLocked) {
+            if (this.plugin.replicator.remoteLocked) {
                 const c = containerHatchEl.createEl("div", {
                     text: "To prevent unwanted vault corruption, the remote database has been locked for synchronization. (This device is marked 'resolved') When all your devices are marked 'resolved', unlock the database.",
                 });
@@ -1695,7 +1795,7 @@ ${stringifyYaml(pluginConfig)}`;
                     .setButtonText("Open")
                     .setDisabled(false)
                     .onClick(() => {
-                        this.plugin.showPluginSyncModal();
+                        this.plugin.addOnPluginAndTheirSettings.showPluginSyncModal();
                     });
             });
 
@@ -1703,84 +1803,91 @@ ${stringifyYaml(pluginConfig)}`;
 
         addScreenElement("60", containerPluginSettings);
 
-        const containerCorruptedDataEl = containerEl.createDiv();
+        // const containerCorruptedDataEl = containerEl.createDiv();
 
-        containerCorruptedDataEl.createEl("h3", { text: "Corrupted or missing data" });
-        containerCorruptedDataEl.createEl("h4", { text: "Corrupted" });
-        if (Object.keys(this.plugin.localDatabase.corruptedEntries).length > 0) {
-            const cx = containerCorruptedDataEl.createEl("div", { text: "If you have a copy of these files on any device, simply edit them once and sync. If not, there's nothing we can do except deleting them. sorry.." });
-            for (const k in this.plugin.localDatabase.corruptedEntries) {
-                const xx = cx.createEl("div", { text: `${k}` });
+        // containerCorruptedDataEl.createEl("h3", { text: "Corrupted or missing data" });
+        // containerCorruptedDataEl.createEl("h4", { text: "Corrupted" });
+        // if (Object.keys(this.plugin.localDatabase.corruptedEntries).length > 0) {
+        //     const cx = containerCorruptedDataEl.createEl("div", { text: "If you have a copy of these files on any device, simply edit them once and sync. If not, there's nothing we can do except deleting them. sorry.." });
+        //     for (const k in this.plugin.localDatabase.corruptedEntries) {
+        //         const xx = cx.createEl("div", { text: `${k}` });
 
-                const ba = xx.createEl("button", { text: `Delete this` }, (e) => {
-                    e.addEventListener("click", async () => {
-                        await this.plugin.localDatabase.deleteDBEntry(k);
-                        xx.remove();
-                    });
-                });
-                ba.addClass("mod-warning");
-                xx.createEl("button", { text: `Restore from file` }, (e) => {
-                    e.addEventListener("click", async () => {
-                        const f = await this.app.vault.getFiles().filter((e) => path2id(e.path) == k);
-                        if (f.length == 0) {
-                            Logger("Not found in vault", LOG_LEVEL.NOTICE);
-                            return;
-                        }
-                        await this.plugin.updateIntoDB(f[0]);
-                        xx.remove();
-                    });
-                });
-                xx.addClass("mod-warning");
-            }
-        } else {
-            containerCorruptedDataEl.createEl("div", { text: "There is no corrupted data." });
-        }
-        containerCorruptedDataEl.createEl("h4", { text: "Missing or waiting" });
-        if (Object.keys(this.plugin.queuedFiles).length > 0) {
-            const cx = containerCorruptedDataEl.createEl("div", {
-                text: "These files have missing or waiting chunks. Perhaps these chunks will arrive in a while after replication. But if they don't, you have to restore it's database entry from a existing local file by hitting the button below.",
-            });
-            const files = [...new Set([...this.plugin.queuedFiles.map((e) => e.entry._id)])];
-            for (const k of files) {
-                const xx = cx.createEl("div", { text: `${id2path(k)}` });
+        //         const ba = xx.createEl("button", { text: `Delete this` }, (e) => {
+        //             e.addEventListener("click", async () => {
+        //                 await this.plugin.localDatabase.deleteDBEntry(k as string as FilePathWithPrefix /* should be explained */);
+        //                 xx.remove();
+        //             });
+        //         });
+        //         ba.addClass("mod-warning");
+        //         //TODO: FIX LATER
+        //         // xx.createEl("button", { text: `Restore from file` }, (e) => {
+        //         //     e.addEventListener("click", async () => {
+        //         //         const f = await this.app.vault.getFiles().filter((e) => this.plugin.path2id(e.path) == k);
+        //         //         if (f.length == 0) {
+        //         //             Logger("Not found in vault", LOG_LEVEL.NOTICE);
+        //         //             return;
+        //         //         }
+        //         //         await this.plugin.updateIntoDB(f[0]);
+        //         //         xx.remove();
+        //         //     });
+        //         // });
+        //         // xx.addClass("mod-warning");
+        //     }
+        // } else {
+        //     containerCorruptedDataEl.createEl("div", { text: "There is no corrupted data." });
+        // }
+        // containerCorruptedDataEl.createEl("h4", { text: "Missing or waiting" });
+        // if (Object.keys(this.plugin.queuedFiles).length > 0) {
+        //     const cx = containerCorruptedDataEl.createEl("div", {
+        //         text: "These files have missing or waiting chunks. Perhaps these chunks will arrive in a while after replication. But if they don't, you have to restore it's database entry from a existing local file by hitting the button below.",
+        //     });
+        //     const files = [...new Set([...this.plugin.queuedFiles.map((e) => e.entry._id)])];
+        //     for (const k of files) {
+        //         const xx = cx.createEl("div", { text: `${this.plugin.id2path(k)}` });
+
+        //         const ba = xx.createEl("button", { text: `Delete this` }, (e) => {
+        //             e.addEventListener("click", async () => {
+        //                 await this.plugin.localDatabase.deleteDBEntry(k);
+        //                 xx.remove();
+        //             });
+        //         });
+        //         ba.addClass("mod-warning");
+        //         xx.createEl("button", { text: `Restore from file` }, (e) => {
+        //             e.addEventListener("click", async () => {
+        //                 const f = await this.app.vault.getFiles().filter((e) => this.plugin.path2id(e.path) == k);
+        //                 if (f.length == 0) {
+        //                     Logger("Not found in vault", LOG_LEVEL.NOTICE);
+        //                     return;
+        //                 }
+        //                 await this.plugin.updateIntoDB(f[0]);
+        //                 xx.remove();
+        //             });
+        //         });
+        //         xx.addClass("mod-warning");
+        //     }
+        // } else {
+        //     containerCorruptedDataEl.createEl("div", { text: "There is no missing or waiting chunk." });
+        // }
+        // applyDisplayEnabled();
+        // addScreenElement("70", containerCorruptedDataEl);
 
-                const ba = xx.createEl("button", { text: `Delete this` }, (e) => {
-                    e.addEventListener("click", async () => {
-                        await this.plugin.localDatabase.deleteDBEntry(k);
-                        xx.remove();
-                    });
-                });
-                ba.addClass("mod-warning");
-                xx.createEl("button", { text: `Restore from file` }, (e) => {
-                    e.addEventListener("click", async () => {
-                        const f = await this.app.vault.getFiles().filter((e) => path2id(e.path) == k);
-                        if (f.length == 0) {
-                            Logger("Not found in vault", LOG_LEVEL.NOTICE);
-                            return;
-                        }
-                        await this.plugin.updateIntoDB(f[0]);
-                        xx.remove();
-                    });
-                });
-                xx.addClass("mod-warning");
-            }
-        } else {
-            containerCorruptedDataEl.createEl("div", { text: "There is no missing or waiting chunk." });
-        }
         applyDisplayEnabled();
-        addScreenElement("70", containerCorruptedDataEl);
-        if (lastVersion != this.plugin.settings.lastReadUpdates) {
-            if (JSON.stringify(this.plugin.settings) != JSON.stringify(DEFAULT_SETTINGS)) {
-                changeDisplay("100");
+        if (this.selectedScreen == "") {
+            if (lastVersion != this.plugin.settings.lastReadUpdates) {
+                if (JSON.stringify(this.plugin.settings) != JSON.stringify(DEFAULT_SETTINGS)) {
+                    changeDisplay("100");
+                } else {
+                    changeDisplay("110")
+                }
             } else {
-                changeDisplay("110")
+                if (isAnySyncEnabled()) {
+                    changeDisplay("0");
+                } else {
+                    changeDisplay("110")
+                }
             }
         } else {
-            if (isAnySyncEnabled()) {
-                changeDisplay("0");
-            } else {
-                changeDisplay("110")
-            }
+            changeDisplay(this.selectedScreen);
         }
     }
 }

src/PluginPane.svelte

@@ -1,8 +1,9 @@
 <script lang="ts">
-    import ObsidianLiveSyncPlugin from "./main";
     import { onMount } from "svelte";
     import { DevicePluginList, PluginDataEntry } from "./types";
     import { versionNumberString2Number } from "./lib/src/strbin";
+    import ObsidianLiveSyncPlugin from "./main";
+    import { PluginAndTheirSettings } from "./CmdPluginAndTheirSettings";
 
     type JudgeResult = "" | "NEWER" | "EVEN" | "EVEN_BUT_DIFFERENT" | "OLDER" | "REMOTE_ONLY";
 
@@ -21,6 +22,13 @@
     let showOwnPlugins = false;
     let targetList: { [key: string]: boolean } = {};
 
+    let addOn: PluginAndTheirSettings;
+    $: {
+        const f = plugin.addOns.filter((e) => e instanceof PluginAndTheirSettings);
+        if (f && f.length > 0) {
+            addOn = f[0] as PluginAndTheirSettings;
+        }
+    }
     function saveTargetList() {
         window.localStorage.setItem("ols-plugin-targetlist", JSON.stringify(targetList));
     }
@@ -39,7 +47,7 @@
     }
 
     async function updateList() {
-        let x = await plugin.getPluginList();
+        let x = await addOn.getPluginList();
         ownPlugins = x.thisDevicePlugins;
         plugins = Object.values(x.allPlugins);
         let targetListItems = Array.from(new Set(plugins.map((e) => e.deviceVaultName + "---" + e.manifest.id)));
@@ -62,7 +70,13 @@
             if (!(p.deviceVaultName in deviceAndPlugins)) {
                 deviceAndPlugins[p.deviceVaultName] = [];
             }
-            let dispInfo: PluginDataEntryDisp = { ...p, versionInfo: "", mtimeInfo: "", versionFlag: "", mtimeFlag: "" };
+            let dispInfo: PluginDataEntryDisp = {
+                ...p,
+                versionInfo: "",
+                mtimeInfo: "",
+                versionFlag: "",
+                mtimeFlag: "",
+            };
             dispInfo.versionInfo = p.manifest.version;
             let x = new Date().getTime() / 1000;
             let mtime = p.mtime / 1000;
@@ -157,7 +171,7 @@
     async function sweepPlugins() {
         //@ts-ignore
         await plugin.app.plugins.loadManifests();
-        await plugin.sweepPlugin(true);
+        await addOn.sweepPlugin(true);
         updateList();
     }
 
@@ -169,9 +183,9 @@
                     const entry = deviceAndPlugins[deviceAndVault].find((e) => e.manifest.id == id);
                     if (entry) {
                         if (opt == "plugin") {
-                            if (entry.versionFlag != "EVEN") await plugin.applyPlugin(entry);
+                            if (entry.versionFlag != "EVEN") await addOn.applyPlugin(entry);
                         } else if (opt == "setting") {
-                            if (entry.mtimeFlag != "EVEN") await plugin.applyPluginData(entry);
+                            if (entry.mtimeFlag != "EVEN") await addOn.applyPluginData(entry);
                         }
                     }
                 }
@@ -179,12 +193,12 @@
         }
         //@ts-ignore
         await plugin.app.plugins.loadManifests();
-        await plugin.sweepPlugin(true);
+        await addOn.sweepPlugin(true);
         updateList();
     }
 
     async function checkUpdates() {
-        await plugin.checkPluginUpdate();
+        await addOn.checkPluginUpdate();
     }
     async function replicateAndRefresh() {
         await plugin.replicate(true);

src/StorageEventManager.ts

@@ -0,0 +1,172 @@
+import { Plugin_2, TAbstractFile, TFile, TFolder } from "./deps";
+import { isPlainText, shouldBeIgnored } from "./lib/src/path";
+import { getGlobalStore } from "./lib/src/store";
+import { FilePath, ObsidianLiveSyncSettings } from "./lib/src/types";
+import { FileEventItem, FileEventType, FileInfo, InternalFileInfo, queueItem } from "./types";
+import { recentlyTouched } from "./utils";
+
+
+export abstract class StorageEventManager {
+    abstract fetchEvent(): FileEventItem | false;
+    abstract cancelRelativeEvent(item: FileEventItem): void;
+    abstract getQueueLength(): number;
+}
+
+type LiveSyncForStorageEventManager = Plugin_2 &
+{
+    settings: ObsidianLiveSyncSettings
+} & {
+    isTargetFile: (file: string | TAbstractFile) => boolean,
+    procFileEvent: (applyBatch?: boolean) => Promise<boolean>
+};
+
+
+export class StorageEventManagerObsidian extends StorageEventManager {
+    plugin: LiveSyncForStorageEventManager;
+    queuedFilesStore = getGlobalStore("queuedFiles", { queuedItems: [] as queueItem[], fileEventItems: [] as FileEventItem[] });
+
+    watchedFileEventQueue = [] as FileEventItem[];
+
+    constructor(plugin: LiveSyncForStorageEventManager) {
+        super();
+        this.plugin = plugin;
+        this.watchVaultChange = this.watchVaultChange.bind(this);
+        this.watchVaultCreate = this.watchVaultCreate.bind(this);
+        this.watchVaultDelete = this.watchVaultDelete.bind(this);
+        this.watchVaultRename = this.watchVaultRename.bind(this);
+        this.watchVaultRawEvents = this.watchVaultRawEvents.bind(this);
+        plugin.registerEvent(app.vault.on("modify", this.watchVaultChange));
+        plugin.registerEvent(app.vault.on("delete", this.watchVaultDelete));
+        plugin.registerEvent(app.vault.on("rename", this.watchVaultRename));
+        plugin.registerEvent(app.vault.on("create", this.watchVaultCreate));
+        //@ts-ignore : Internal API
+        plugin.registerEvent(app.vault.on("raw", this.watchVaultRawEvents));
+    }
+
+    watchVaultCreate(file: TAbstractFile, ctx?: any) {
+        this.appendWatchEvent([{ type: "CREATE", file }], ctx);
+    }
+
+    watchVaultChange(file: TAbstractFile, ctx?: any) {
+        this.appendWatchEvent([{ type: "CHANGED", file }], ctx);
+    }
+
+    watchVaultDelete(file: TAbstractFile, ctx?: any) {
+        this.appendWatchEvent([{ type: "DELETE", file }], ctx);
+    }
+    watchVaultRename(file: TAbstractFile, oldFile: string, ctx?: any) {
+        if (file instanceof TFile) {
+            this.appendWatchEvent([
+                { type: "CREATE", file },
+                { type: "DELETE", file: { path: oldFile as FilePath, mtime: file.stat.mtime, ctime: file.stat.ctime, size: file.stat.size, deleted: true } },
+            ], ctx);
+        }
+    }
+    // Watch raw events (Internal API)
+    watchVaultRawEvents(path: FilePath) {
+        if (!this.plugin.settings.syncInternalFiles) return;
+        if (!this.plugin.settings.watchInternalFileChanges) return;
+        if (!path.startsWith(app.vault.configDir)) return;
+        const ignorePatterns = this.plugin.settings.syncInternalFilesIgnorePatterns
+            .replace(/\n| /g, "")
+            .split(",").filter(e => e).map(e => new RegExp(e, "i"));
+        if (ignorePatterns.some(e => path.match(e))) return;
+        this.appendWatchEvent(
+            [{
+                type: "INTERNAL",
+                file: { path, mtime: 0, ctime: 0, size: 0 }
+            }], null);
+    }
+
+    // Cache file and waiting to can be proceed.
+    async appendWatchEvent(params: { type: FileEventType, file: TAbstractFile | InternalFileInfo, oldPath?: string }[], ctx?: any) {
+        let forcePerform = false;
+        for (const param of params) {
+            if (shouldBeIgnored(param.file.path)) {
+                continue;
+            }
+            const atomicKey = [0, 0, 0, 0, 0, 0].map(e => `${Math.floor(Math.random() * 100000)}`).join("-");
+            const type = param.type;
+            const file = param.file;
+            const oldPath = param.oldPath;
+            if (file instanceof TFolder) continue;
+            if (!this.plugin.isTargetFile(file.path)) continue;
+            if (this.plugin.settings.suspendFileWatching) continue;
+
+            let cache: null | string | ArrayBuffer;
+            // new file or something changed, cache the changes.
+            if (file instanceof TFile && (type == "CREATE" || type == "CHANGED")) {
+                if (recentlyTouched(file)) {
+                    continue;
+                }
+                if (!isPlainText(file.name)) {
+                    cache = await app.vault.readBinary(file);
+                } else {
+                    // cache = await this.app.vault.read(file);
+                    cache = await app.vault.cachedRead(file);
+                    if (!cache) cache = await app.vault.read(file);
+                }
+            }
+            if (type == "DELETE" || type == "RENAME") {
+                forcePerform = true;
+            }
+
+
+            if (this.plugin.settings.batchSave) {
+                // if the latest event is the same type, omit that
+                // a.md MODIFY  <- this should be cancelled when a.md MODIFIED
+                // b.md MODIFY    <- this should be cancelled when b.md MODIFIED
+                // a.md MODIFY
+                // a.md CREATE
+                //     : 
+                let i = this.watchedFileEventQueue.length;
+                L1:
+                while (i >= 0) {
+                    i--;
+                    if (i < 0) break L1;
+                    if (this.watchedFileEventQueue[i].args.file.path != file.path) {
+                        continue L1;
+                    }
+                    if (this.watchedFileEventQueue[i].type != type) break L1;
+                    this.watchedFileEventQueue.remove(this.watchedFileEventQueue[i]);
+                    //this.queuedFilesStore.set({ queuedItems: this.queuedFiles, fileEventItems: this.watchedFileEventQueue });
+                    this.queuedFilesStore.apply((value) => ({ ...value, fileEventItems: this.watchedFileEventQueue }));
+                }
+            }
+
+            const fileInfo = file instanceof TFile ? {
+                ctime: file.stat.ctime,
+                mtime: file.stat.mtime,
+                file: file,
+                path: file.path,
+                size: file.stat.size
+            } as FileInfo : file as InternalFileInfo;
+            this.watchedFileEventQueue.push({
+                type,
+                args: {
+                    file: fileInfo,
+                    oldPath,
+                    cache,
+                    ctx
+                },
+                key: atomicKey
+            })
+        }
+        // this.queuedFilesStore.set({ queuedItems: this.queuedFiles, fileEventItems: this.watchedFileEventQueue });
+        this.queuedFilesStore.apply((value) => ({ ...value, fileEventItems: this.watchedFileEventQueue }));
+        this.plugin.procFileEvent(forcePerform);
+    }
+    fetchEvent(): FileEventItem | false {
+        if (this.watchedFileEventQueue.length == 0) return false;
+        const item = this.watchedFileEventQueue.shift();
+        this.queuedFilesStore.apply((value) => ({ ...value, fileEventItems: this.watchedFileEventQueue }));
+        return item;
+    }
+    cancelRelativeEvent(item: FileEventItem) {
+        this.watchedFileEventQueue = [...this.watchedFileEventQueue].filter(e => e.key != item.key);
+        this.queuedFilesStore.apply((value) => ({ ...value, fileEventItems: this.watchedFileEventQueue }));
+    }
+    getQueueLength() {
+        return this.watchedFileEventQueue.length;
+    }
+}

src/deps.ts

@@ -0,0 +1,11 @@
+import { FilePath } from "./lib/src/types";
+
+export {
+    addIcon, App, DataWriteOptions, debounce, Editor, FuzzySuggestModal, MarkdownRenderer, MarkdownView, Modal, Notice, Platform, Plugin, PluginManifest,
+    PluginSettingTab, Plugin_2, requestUrl, RequestUrlParam, RequestUrlResponse, sanitizeHTMLToDom, Setting, stringifyYaml, TAbstractFile, TextAreaComponent, TFile, TFolder,
+} from "obsidian";
+import {
+    normalizePath as normalizePath_
+} from "obsidian";
+const normalizePath = normalizePath_ as <T extends string | FilePath>(from: T) => T;
+export { normalizePath }

src/dialogs.ts

@@ -1,4 +1,4 @@
-import { App, FuzzySuggestModal, Modal, Setting } from "obsidian";
+import { App, FuzzySuggestModal, Modal, Setting } from "./deps";
 import ObsidianLiveSyncPlugin from "./main";
 
 //@ts-ignore

src/types.ts

@@ -1,5 +1,5 @@
-import { PluginManifest, TFile } from "obsidian";
-import { DatabaseEntry, EntryBody } from "./lib/src/types";
+import { PluginManifest, TFile } from "./deps";
+import { DatabaseEntry, EntryBody, FilePath } from "./lib/src/types";
 
 export interface PluginDataEntry extends DatabaseEntry {
     deviceVaultName: string;
@@ -24,7 +24,7 @@ export interface DevicePluginList {
 export const PERIODIC_PLUGIN_SWEEP = 60;
 
 export interface InternalFileInfo {
-    path: string;
+    path: FilePath;
     mtime: number;
     ctime: number;
     size: number;
@@ -32,7 +32,7 @@ export interface InternalFileInfo {
 }
 
 export interface FileInfo {
-    path: string;
+    path: FilePath;
     mtime: number;
     ctime: number;
     size: number;
@@ -46,4 +46,29 @@ export type queueItem = {
     timeout?: number;
     done?: boolean;
     warned?: boolean;
-};
+};
+
+export type CacheData = string | ArrayBuffer;
+export type FileEventType = "CREATE" | "DELETE" | "CHANGED" | "RENAME" | "INTERNAL";
+export type FileEventArgs = {
+    file: FileInfo | InternalFileInfo;
+    cache?: CacheData;
+    oldPath?: string;
+    ctx?: any;
+}
+export type FileEventItem = {
+    type: FileEventType,
+    args: FileEventArgs,
+    key: string,
+}
+
+export const CHeader = "h:";
+export const PSCHeader = "ps:";
+export const PSCHeaderEnd = "ps;";
+export const ICHeader = "i:";
+export const ICHeaderEnd = "i;";
+export const ICHeaderLength = ICHeader.length;
+
+export const FileWatchEventQueueMax = 10;
+export const configURIBase = "obsidian://setuplivesync?settings=";
+

src/utils.ts

@@ -1,54 +1,84 @@
-import { DataWriteOptions, normalizePath, TFile, Platform } from "obsidian";
-import { path2id_base, id2path_base, isValidFilenameInLinux, isValidFilenameInDarwin, isValidFilenameInWidows, isValidFilenameInAndroid } from "./lib/src/path";
+import { DataWriteOptions, normalizePath, TFile, Platform, TAbstractFile, App, Plugin_2 } from "./deps";
+import { path2id_base, id2path_base, isValidFilenameInLinux, isValidFilenameInDarwin, isValidFilenameInWidows, isValidFilenameInAndroid, stripAllPrefixes } from "./lib/src/path";
 
 import { Logger } from "./lib/src/logger";
-import { LOG_LEVEL } from "./lib/src/types";
+import { AnyEntry, DocumentID, EntryHasPath, FilePath, FilePathWithPrefix, LOG_LEVEL } from "./lib/src/types";
+import { CHeader, ICHeader, ICHeaderLength, PSCHeader } from "./types";
+import { InputStringDialog, PopoverSelectString } from "./dialogs";
 
 // For backward compatibility, using the path for determining id.
 // Only CouchDB unacceptable ID (that starts with an underscore) has been prefixed with "/".
 // The first slash will be deleted when the path is normalized.
-export function path2id(filename: string): string {
-    const x = normalizePath(filename);
-    return path2id_base(x);
+export async function path2id(filename: FilePathWithPrefix | FilePath, obfuscatePassphrase: string | false): Promise<DocumentID> {
+    const temp = filename.split(":");
+    const path = temp.pop();
+    const normalizedPath = normalizePath(path as FilePath);
+    temp.push(normalizedPath);
+    const fixedPath = temp.join(":") as FilePathWithPrefix;
+
+    const out = await path2id_base(fixedPath, obfuscatePassphrase);
+    return out;
 }
-export function id2path(filename: string): string {
-    return id2path_base(normalizePath(filename));
+export function id2path(id: DocumentID, entry?: EntryHasPath): FilePathWithPrefix {
+    const filename = id2path_base(id, entry);
+    const temp = filename.split(":");
+    const path = temp.pop();
+    const normalizedPath = normalizePath(path as FilePath);
+    temp.push(normalizedPath);
+    const fixedPath = temp.join(":") as FilePathWithPrefix;
+    return fixedPath;
+}
+export function getPath(entry: AnyEntry) {
+    return id2path(entry._id, entry);
+
+}
+export function getPathWithoutPrefix(entry: AnyEntry) {
+    const f = getPath(entry);
+    return stripAllPrefixes(f);
 }
 
-const triggers: { [key: string]: ReturnType<typeof setTimeout> } = {};
-export function setTrigger(key: string, timeout: number, proc: (() => Promise<any> | void)) {
-    clearTrigger(key);
-    triggers[key] = setTimeout(async () => {
-        delete triggers[key];
+export function getPathFromTFile(file: TAbstractFile) {
+    return file.path as FilePath;
+}
+
+const tasks: { [key: string]: ReturnType<typeof setTimeout> } = {};
+export function scheduleTask(key: string, timeout: number, proc: (() => Promise<any> | void)) {
+    cancelTask(key);
+    tasks[key] = setTimeout(async () => {
+        delete tasks[key];
         await proc();
     }, timeout);
 }
-export function clearTrigger(key: string) {
-    if (key in triggers) {
-        clearTimeout(triggers[key]);
+export function cancelTask(key: string) {
+    if (key in tasks) {
+        clearTimeout(tasks[key]);
+        delete tasks[key];
     }
 }
-export function clearAllTriggers() {
-    for (const v in triggers) {
-        clearTimeout(triggers[v]);
+export function cancelAllTasks() {
+    for (const v in tasks) {
+        clearTimeout(tasks[v]);
+        delete tasks[v];
     }
 }
 const intervals: { [key: string]: ReturnType<typeof setInterval> } = {};
-export function setPeriodic(key: string, timeout: number, proc: (() => Promise<any> | void)) {
-    clearPeriodic(key);
+export function setPeriodicTask(key: string, timeout: number, proc: (() => Promise<any> | void)) {
+    cancelPeriodicTask(key);
     intervals[key] = setInterval(async () => {
         delete intervals[key];
         await proc();
     }, timeout);
 }
-export function clearPeriodic(key: string) {
+export function cancelPeriodicTask(key: string) {
     if (key in intervals) {
         clearInterval(intervals[key]);
+        delete intervals[key];
     }
 }
-export function clearAllPeriodic() {
+export function cancelAllPeriodicTask() {
     for (const v in intervals) {
         clearInterval(intervals[v]);
+        delete intervals[v];
     }
 }
 
@@ -290,4 +320,109 @@ export function isValidPath(filename: string) {
     //Fallback
     Logger("Could not determine platform for checking filename", LOG_LEVEL.VERBOSE);
     return isValidFilenameInWidows(filename);
-}
+}
+
+let touchedFiles: string[] = [];
+
+export function getAbstractFileByPath(path: FilePath): TAbstractFile | null {
+    // Hidden API but so useful.
+    // @ts-ignore
+    if ("getAbstractFileByPathInsensitive" in app.vault && (app.vault.adapter?.insensitive ?? false)) {
+        // @ts-ignore
+        return app.vault.getAbstractFileByPathInsensitive(path);
+    } else {
+        return app.vault.getAbstractFileByPath(path);
+    }
+}
+export function trimPrefix(target: string, prefix: string) {
+    return target.startsWith(prefix) ? target.substring(prefix.length) : target;
+}
+
+export function touch(file: TFile | FilePath) {
+    const f = file instanceof TFile ? file : getAbstractFileByPath(file) as TFile;
+    const key = `${f.path}-${f.stat.mtime}-${f.stat.size}`;
+    touchedFiles.unshift(key);
+    touchedFiles = touchedFiles.slice(0, 100);
+}
+export function recentlyTouched(file: TFile) {
+    const key = `${file.path}-${file.stat.mtime}-${file.stat.size}`;
+    if (touchedFiles.indexOf(key) == -1) return false;
+    return true;
+}
+export function clearTouched() {
+    touchedFiles = [];
+}
+
+/**
+ * returns is internal chunk of file
+ * @param id ID
+ * @returns 
+ */
+export function isIdOfInternalMetadata(id: FilePath | FilePathWithPrefix | DocumentID): boolean {
+    return id.startsWith(ICHeader);
+}
+export function stripInternalMetadataPrefix<T extends FilePath | FilePathWithPrefix | DocumentID>(id: T): T {
+    return id.substring(ICHeaderLength) as T;
+}
+export function id2InternalMetadataId(id: DocumentID): DocumentID {
+    return ICHeader + id as DocumentID;
+}
+
+// const CHeaderLength = CHeader.length;
+export function isChunk(str: string): boolean {
+    return str.startsWith(CHeader);
+}
+
+export function isPluginMetadata(str: string): boolean {
+    return str.startsWith(PSCHeader);
+}
+
+export const askYesNo = (app: App, message: string): Promise<"yes" | "no"> => {
+    return new Promise((res) => {
+        const popover = new PopoverSelectString(app, message, null, null, (result) => res(result as "yes" | "no"));
+        popover.open();
+    });
+};
+
+export const askSelectString = (app: App, message: string, items: string[]): Promise<string> => {
+    const getItemsFun = () => items;
+    return new Promise((res) => {
+        const popover = new PopoverSelectString(app, message, "", getItemsFun, (result) => res(result));
+        popover.open();
+    });
+};
+
+
+export const askString = (app: App, title: string, key: string, placeholder: string): Promise<string | false> => {
+    return new Promise((res) => {
+        const dialog = new InputStringDialog(app, title, key, placeholder, (result) => res(result));
+        dialog.open();
+    });
+};
+
+
+export class PeriodicProcessor {
+    _process: () => Promise<any>;
+    _timer?: number;
+    _plugin: Plugin_2;
+    constructor(plugin: Plugin_2, process: () => Promise<any>) {
+        this._plugin = plugin;
+        this._process = process;
+    }
+    async process() {
+        try {
+            await this._process();
+        } catch (ex) {
+            Logger(ex);
+        }
+    }
+    enable(interval: number) {
+        this.disable();
+        if (interval == 0) return;
+        this._timer = window.setInterval(() => this._process().then(() => { }), interval);
+        this._plugin.registerInterval(this._timer);
+    }
+    disable() {
+        if (this._timer) clearInterval(this._timer);
+    }
+}

updates.md

@@ -1,3 +1,24 @@
+### 0.18.0
+
+#### Now, paths of files in the database can now be obfuscated. (Experimental Feature)
+At before v0.18.0, Self-hosted LiveSync used the path of files, to detect and resolve conflicts. In naive. The ID of the document stored in the CouchDB was naturally the filename.
+However, it means a sort of lacking confidentiality. If the credentials of the database have been leaked, the attacker (or an innocent bystander) can read the path of files. So we could not use confidential things in the filename in some environments.
+Since v0.18.0, they can be obfuscated. so it is no longer possible to decipher the path from the ID. Instead of that, it costs a bit CPU load than before, and the data structure has been changed a bit.
+
+We can configure the `Path Obfuscation` in the `Remote database configuration` pane.  
+Note: **When changing this configuration, we need to rebuild both of the local and the remote databases**.
+
+#### Minors 
+- 0.18.1
+  - Fixed:
+    - Some messages are fixed (Typo)
+    - File type detection now works fine!
+- 0.18.2
+  - Improved:
+    - The setting pane has been refined.
+    - We can enable `hidden files sync` with several initial behaviours; `Merge`, `Fetch` remote, and `Overwrite` remote.
+    - No longer `Touch hidden files`.
+
 ### 0.17.0
 - 0.17.0 has no surfaced changes but the design of saving chunks has been changed. They have compatibility but changing files after upgrading makes different chunks than before 0.16.x.
   Please rebuild databases once if you have been worried about storage usage.
@@ -10,43 +31,24 @@
     - Chunk ID numbering rules
 
 #### Minors
-- __0.17.1 to 0.17.25 has been moved into `update_old.md`__
-- 0.17.26
-  - Fixed(Urgent):
-    - The modified document will be reflected in the storage now.
-- 0.17.27
-  - Improved:
-    - Now, the filename of the conflicted settings will be shown on the merging dialogue
-    - The plugin data can be resolved when conflicted.
-    - The semaphore status display has been changed to count only.
-    - Applying to the storage will be concurrent with a few files.
-- 0.17.28
-  -Fixed:
-    - Some messages have been refined.
-    - Boot sequence has been speeded up.
-    - Opening the local database multiple times in a short duration has been suppressed.
-    - Older migration logic. 
-      - Note: If you have used 0.10.0 or lower and have not upgraded, you will need to run 0.17.27 or earlier once or reinstall Obsidian.
-- 0.17.29
-  - Fixed:
-    - Requests of reading chunks online are now split into a reasonable(and configurable) size.
-    - No longer error message will be shown on Linux devices with hidden file synchronisation.
-  - Improved:
-    - The interval of reading chunks online is now configurable.
-    - Boot sequence has been speeded up, more.
-  - Misc:
-    - Messages on the boot sequence will now be more detailed. If you want to see them, please enable the verbose log.
-    - Logs became be kept for 1000 lines while the verbose log is enabled.
-- 0.17.30
-  - Implemented:
-    - `Resolve all conflicted files` has been implemented.
-  - Fixed:
-    - Fixed a problem about reading chunks online when a file has more chunks than the concurrency limit.
-  - Rollbacked:
-    - Logs are kept only for 100 lines, again.
+- __0.17.1 to 0.17.30 has been moved into `update_old.md`__
 - 0.17.31
   - Fixed:
     - Now `redflag3` can be run surely.
     - Synchronisation can now be aborted.
   - Note: The synchronisation flow has been rewritten drastically. Please do not haste to inform me if you have noticed anything.
+- 0.17.32
+  - Fixed:
+    - Now periodic internal file scanning works well.
+    - The handler of Window-visibility-changed has been fixed.
+    - And minor fixes possibly included.
+  - Refactored:
+    - Unused logic has been removed.
+    - Some utility functions have been moved into suitable files.
+    - Function names have been renamed.
+- 0.17.33
+  - Maintenance update: Refactored; the responsibilities that `LocalDatabase` had were shared. (Hoping) No changes in behaviour.
+- 0.17.34
+  - Fixed: The `Fetch` that was broken at 0.17.33 has been fixed.
+  - Refactored again: Internal file sync, plug-in sync and Set up URI have been moved into each file.
 ... To continue on to `updates_old.md`.

updates_old.md

@@ -122,6 +122,39 @@
 - 0.17.25
   - Fixed:
     - Now reading error will be reported.
+- 0.17.26
+  - Fixed(Urgent):
+    - The modified document will be reflected in the storage now.
+- 0.17.27
+  - Improved:
+    - Now, the filename of the conflicted settings will be shown on the merging dialogue
+    - The plugin data can be resolved when conflicted.
+    - The semaphore status display has been changed to count only.
+    - Applying to the storage will be concurrent with a few files.
+- 0.17.28
+  -Fixed:
+    - Some messages have been refined.
+    - Boot sequence has been speeded up.
+    - Opening the local database multiple times in a short duration has been suppressed.
+    - Older migration logic. 
+      - Note: If you have used 0.10.0 or lower and have not upgraded, you will need to run 0.17.27 or earlier once or reinstall Obsidian.
+- 0.17.29
+  - Fixed:
+    - Requests of reading chunks online are now split into a reasonable(and configurable) size.
+    - No longer error message will be shown on Linux devices with hidden file synchronisation.
+  - Improved:
+    - The interval of reading chunks online is now configurable.
+    - Boot sequence has been speeded up, more.
+  - Misc:
+    - Messages on the boot sequence will now be more detailed. If you want to see them, please enable the verbose log.
+    - Logs became be kept for 1000 lines while the verbose log is enabled.
+- 0.17.30
+  - Implemented:
+    - `Resolve all conflicted files` has been implemented.
+  - Fixed:
+    - Fixed a problem about reading chunks online when a file has more chunks than the concurrency limit.
+  - Rollbacked:
+    - Logs are kept only for 100 lines, again.
 ### 0.16.0
 - Now hidden files need not be scanned. Changes will be detected automatically.
   - If you want it to back to its previous behaviour, please disable `Monitor changes to internal files`.