Merge branch 'fix_warns' into improve_first_fetch

Fixed wrong typing for serviceHub, svelte dialog

.github/ISSUE_TEMPLATE/issue-report.md

@@ -2,7 +2,7 @@
 name: Issue report
 about: Create a report to help us improve
 title: ''
-labels: 'bug'
+labels: 'uncategorised'
 assignees: ''
 
 ---
@@ -53,11 +53,12 @@ The hatch report (below) includes version information. If you cannot provide the
 
 - Self-hosted LiveSync version: <!-- e.g. 0.23.0 — find it in Obsidian Settings → Community Plugins -->
 
-### Report from LiveSync
-Open the `Hatch` pane in LiveSync settings and press `Make report`. Paste here or upload to [Gist](https://gist.github.com/) and share the link.
+### Report and Logs from LiveSync
+Perform a `Generate full report for opening the issue with debug info` command and provide the generated report. This contains detailed information and recent 1000 log lines, which is very helpful for debugging. **PLEASE AMEND THE REPORT TO REMOVE ANY SENSITIVE INFORMATION BEFORE PASTING.**
+If too large to paste here, upload to [Gist](https://gist.github.com/) and share the link.
 
 <details>
-<summary>Report from hatch (primary)</summary>
+<summary>Report and Logs (primary)</summary>
 
 ```
 <!-- paste here or link to Gist -->
@@ -65,29 +66,7 @@ Open the `Hatch` pane in LiveSync settings and press `Make report`. Paste here o
 </details>
 
 <details>
-<summary>Report from hatch (if applicable)</summary>
-
-```
-<!-- paste here or link to Gist -->
-```
-</details>
-
-
-### Plug-in log
-Enable `Verbose Log` in General Settings first, then reproduce the issue and copy the log (tap the document box icon in the ribbon).
-Paste here or upload to [Gist](https://gist.github.com/) and share the link.
-
-<details>
-<summary>Plug-in log (primary)</summary>
-
-```
-<!-- paste here or link to Gist -->
-```
-</details>
-
-
-<details>
-<summary>Plug-in log (if applicable)</summary>
+<summary>Report and Logs (if applicable)</summary>
 
 ```
 <!-- paste here or link to Gist -->

.github/workflows/cli-deno-tests.yml

@@ -17,9 +17,48 @@ permissions:
   contents: read
 
 jobs:
+  prepare:
+    runs-on: ubuntu-latest
+    outputs:
+      task_matrix: ${{ steps.select.outputs.task_matrix }}
+    steps:
+      - name: Select task matrix
+        id: select
+        shell: bash
+        run: |
+          set -euo pipefail
+          SELECTED_TASK="${{ github.event_name == 'workflow_dispatch' && inputs.test_task || 'test' }}"
+          echo "[INFO] Selected task set: $SELECTED_TASK"
+
+          case "$SELECTED_TASK" in
+            test)
+              TASK_MATRIX='["test:setup-put-cat","test:mirror","test:push-pull","test:sync-two-local","test:sync-locked-remote","test:p2p-host","test:p2p-peers","test:p2p-sync","test:p2p-three-nodes","test:p2p-upload-download","test:e2e-couchdb","test:e2e-matrix"]'
+              ;;
+            test:local)
+              TASK_MATRIX='["test:setup-put-cat","test:mirror"]'
+              ;;
+            test:e2e-matrix)
+              TASK_MATRIX='["test:e2e-matrix"]'
+              ;;
+            test:p2p-sync)
+              TASK_MATRIX='["test:p2p-sync"]'
+              ;;
+            *)
+              echo "[ERROR] Unknown task set: $SELECTED_TASK" >&2
+              exit 1
+              ;;
+          esac
+
+          echo "task_matrix=$TASK_MATRIX" >> "$GITHUB_OUTPUT"
+
   test:
+    needs: prepare
     runs-on: ubuntu-latest
     timeout-minutes: 60
+    strategy:
+      fail-fast: false
+      matrix:
+        task: ${{ fromJson(needs.prepare.outputs.task_matrix) }}
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -64,7 +103,7 @@ jobs:
           LIVESYNC_DOCKER_MODE: native
           LIVESYNC_CLI_RETRY: 3
         run: |
-          TASK="${{ github.event_name == 'workflow_dispatch' && inputs.test_task || 'test' }}"
+          TASK="${{ matrix.task }}"
           echo "[INFO] Running Deno task: $TASK"
           deno task "$TASK"
 

.github/workflows/release.yml

@@ -9,6 +9,10 @@ on:
 jobs:
   build:
     runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      id-token: write
+      attestations: write
     steps:
     - uses: actions/checkout@v4
       with:
@@ -29,68 +33,20 @@ jobs:
       run: |
         npm ci
         npm run build --if-present
+    # Attest
+    - name: Attest Plugin Artifacts
+      uses: actions/attest-build-provenance@v4
+      with:
+          subject-path: |
+              main.js
+              manifest.json
+              styles.css
     # Package the required files into a zip
     - name: Package
       run: |
         mkdir ${{ github.event.repository.name }}
         cp main.js manifest.json styles.css README.md ${{ github.event.repository.name }}
         zip -r ${{ github.event.repository.name }}.zip ${{ github.event.repository.name }}
-    # Create the release on github
-    # - name: Create Release
-    #   id: create_release
-    #   uses: actions/create-release@v1
-    #   env:
-    #     GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-    #     VERSION: ${{ steps.version.outputs.tag }}
-    #   with:
-    #     tag_name: ${{ steps.version.outputs.tag }}
-    #     release_name: ${{ steps.version.outputs.tag }}
-    #     draft: true
-    #     prerelease: false
-    # # Upload the packaged release file
-    # - name: Upload zip file
-    #   id: upload-zip
-    #   uses: actions/upload-release-asset@v1
-    #   env:
-    #     GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-    #   with:
-    #     upload_url: ${{ steps.create_release.outputs.upload_url }}
-    #     asset_path: ./${{ github.event.repository.name }}.zip
-    #     asset_name: ${{ github.event.repository.name }}-${{ steps.version.outputs.tag }}.zip
-    #     asset_content_type: application/zip
-    # # Upload the main.js
-    # - name: Upload main.js
-    #   id: upload-main
-    #   uses: actions/upload-release-asset@v1
-    #   env:
-    #     GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-    #   with:
-    #     upload_url: ${{ steps.create_release.outputs.upload_url }} 
-    #     asset_path: ./main.js
-    #     asset_name: main.js
-    #     asset_content_type: text/javascript
-    # # Upload the manifest.json
-    # - name: Upload manifest.json
-    #   id: upload-manifest
-    #   uses: actions/upload-release-asset@v1
-    #   env:
-    #     GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-    #   with:
-    #     upload_url: ${{ steps.create_release.outputs.upload_url }} 
-    #     asset_path: ./manifest.json
-    #     asset_name: manifest.json
-    #     asset_content_type: application/json
-    # # Upload the style.css
-    # - name: Upload styles.css
-    #   id: upload-css
-    #   uses: actions/upload-release-asset@v1
-    #   env:
-    #     GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-    #   with:
-    #     upload_url: ${{ steps.create_release.outputs.upload_url }} 
-    #     asset_path: ./styles.css
-    #     asset_name: styles.css
-    #     asset_content_type: text/css
     - name: Create Release and Upload Assets
       uses: softprops/action-gh-release@v2
       with:

.github/workflows/unit-ci.yml

@@ -10,7 +10,18 @@ on:
     paths:
       - 'src/**'
       - 'test/**'
-      - 'lib/**'
+      - 'package.json'
+      - 'package-lock.json'
+      - 'tsconfig.json'
+      - 'vite.config.ts'
+      - 'vitest.config*.ts'
+      - 'esbuild.config.mjs'
+      - 'eslint.config.mjs'
+      - '.github/workflows/unit-ci.yml'
+  pull_request:
+    paths:
+      - 'src/**'
+      - 'test/**'
       - 'package.json'
       - 'package-lock.json'
       - 'tsconfig.json'

.gitignore

@@ -28,4 +28,7 @@ data.json
 cov_profile/**
 
 coverage
-src/apps/cli/dist/*
+src/apps/cli/dist/*
+_testdata/**
+utils/bench/splitResults.csv
+.eslintcache

.prettierrc.mjs

@@ -13,7 +13,7 @@ const prettierConfig = {
     tabWidth: 4,
     printWidth: 120,
     semi: true,
-    endOfLine: "cr",
+    endOfLine: "lf",
     ...localPrettierConfig,
 };
 

README.md

@@ -4,7 +4,7 @@
 
 Self-hosted LiveSync is a community-developed synchronisation plug-in available on all Obsidian-compatible platforms. It leverages robust server solutions such as CouchDB or object storage systems (e.g., MinIO, S3, R2, etc.) to ensure reliable data synchronisation.
 
-Additionally, it supports peer-to-peer synchronisation using WebRTC now (experimental), enabling you to synchronise your notes directly between devices without relying on a server.
+Additionally, it supports peer-to-peer synchronisation using WebRTC, enabling you to synchronise your notes directly between devices without relying on a server. Documentations is available for [Peer-to-Peer Synchronisation](./docs/p2p_sync_updates_2026.md).
 
 ![obsidian_live_sync_demo](https://user-images.githubusercontent.com/45774780/137355323-f57a8b09-abf2-4501-836c-8cb7d2ff24a3.gif)
 

devs.md

@@ -17,7 +17,7 @@ The plugin uses a dynamic module system to reduce coupling and improve maintaina
     - `coreObsidian/` - Obsidian-specific core (e.g., `ModuleFileAccessObsidian`)
     - `essential/` - Required modules (e.g., `ModuleMigration`, `ModuleKeyValueDB`)
     - `features/` - Optional features (e.g., `ModuleLog`, `ModuleObsidianSettings`)
-    - `extras/` - Development/testing tools (e.g., `ModuleDev`, `ModuleIntegratedTest`)
+    - `extras/` - Development/testing tools (e.g., `ModuleDev`, ~~`ModuleIntegratedTest`~~)
 - **Services**: Core services (e.g., `database`, `replicator`, `storageAccess`) are registered in `ServiceHub` and accessed by modules. They provide an extension point for add new behaviour without modifying existing code.
     - For example, checks before the replication can be added to the `replication.onBeforeReplicate` handler, and the handlers can be return `false` to prevent replication-starting. `vault.isTargetFile` also can be used to prevent processing specific files.
 - **ServiceModule**: A new type of module that directly depends on services.
@@ -63,6 +63,9 @@ npm test             # Run vitest tests (requires Docker services)
 
 ### Environment Setup
 
+- Clone with submodules: `git clone --recurse-submodules <repository-url>`
+- If you already cloned without them, run: `git submodule update --init --recursive`
+- The shared common library is provided by the `src/lib` submodule, and builds will fail if it is missing
 - Create `.env` file with `PATHS_TEST_INSTALL` pointing to test vault plug-in directories (`:` separated on Unix, `;` on Windows)
 - Development builds auto-copy to these paths on build
 

docs/p2p_sync_updates_2026.md

@@ -0,0 +1,59 @@
+# User Guide: Peer-to-Peer Synchronisation (2026 Edition)
+
+Peer-to-Peer (P2P) synchronisation has evolved significantly. This guide covers the essential setup and the new features introduced in the 2026 updates.
+
+## 1. Core Concept: Server-less Freedom
+P2P synchronisation allows your devices to talk directly to each other using WebRTC. A central server is not required for data storage, ensuring maximum privacy and "freedom."
+
+## 2. Setting Up via P2P Status Pane
+You no longer need to navigate through complex menus. Simply open the **P2P Status** (via the ribbon icon or command palette) and click the **⚙ (Cog)** icon.
+
+This opens the **P2P Setup** dialogue where you can configure the essentials:
+- **Room ID:** A unique identifier for your synchronisation group.
+- **Passphrase:** Your encryption key. Ensure all your devices use the exact same passphrase. 
+- **Device Name:** A recognisable name for the current device (e.g., `iphone-16`).
+
+Once you have saved the settings, return to the **P2P Status Pane** and click the **Connect** button to join the network.
+
+*Tip: You can also toggle **Auto Connect** in the setup dialogue to automatically join the network whenever Obsidian starts.*
+
+## 3. Real-time Control
+The status pane in the right sidebar provides granular control over your synchronisation:
+
+- **Active P2P Remote (new):** P2P now has its own active remote selection, separate from the normal active remote for database replication. Use the combo box next to the cog icon to choose which P2P remote configuration is active for P2P features.
+- **Create P2P Remote (new):** Use the **+** button to open the P2P setup dialogue and create a dedicated P2P remote configuration. This is recommended when no P2P active remote has been selected yet.
+- **Selection required (new):** If no P2P active remote is selected, the pane asks for selection before P2P target-related changes are saved.
+
+- **Signalling Status:** Shows if you are connected to the relay (🟢 Online).
+- **Live-push (Broadcast):** Toggle "Broadcast changes" to notify other peers whenever you make an edit.
+- **Replicate now (🔄):** Start immediate bidirectional replication with a visible peer (Pull, then Push).
+- **Watch (🔔/🔕):** Enable "Watch" on specific peers to automatically pull changes when they broadcast. This creates a "LiveSync-like" experience.
+- **Sync target (🔗/⛓️‍💥):** Mark specific peers as **sync targets**. Peers marked here will be included when you run the **"P2P: Sync with targets"** command (see section 5). Click the button next to a peer to toggle it on (🔗, highlighted) or off (⛓️‍💥). This setting is persisted in your configuration.
+
+## 4. Replication Dialogue
+If you want to synchronise with a specific peer manually, use the **Replication** command or button. This opens the **Replication Dialogue** listing available devices.
+
+Inside the dialogue, the **Server Status** card at the top confirms you are still connected while performing the sync.
+The status card now shows a stable **Room ID suffix** above **Peer ID**. The Room ID suffix is better for identifying your P2P group, while Peer ID may change between connections.
+
+Two actions are available per peer:
+
+- **Sync** — Starts a bidirectional synchronisation (Pull then Push) and keeps the dialogue open so you can monitor progress or sync with additional peers.
+- **Start Sync & Close** — Starts the same bidirectional sync in the background and **immediately closes the dialogue**, so you can continue working without waiting.
+
+## 5. Syncing with Registered Targets via Command Palette
+
+You can now trigger a synchronisation with all your pre-registered target peers in one step, without opening any UI.
+
+1. Open the **Command Palette** (`Ctrl/Cmd + P`).
+2. Run **"P2P: Sync with targets"**.
+
+This command synchronises with every peer whose **SYNC** toggle is enabled in the **Detected Peers** list. If no targets are registered, or if the P2P server is not running, the command will notify you accordingly.
+
+*Tip: Pair this command with a hotkey for a quick, keyboard-driven sync workflow.*
+
+## 6. Technical Improvements in 2026
+- **Decoupled Architecture:** The UI is now strictly separated from the core logic, making the plugin more stable across different platforms (Mobile, Desktop, and Web).
+- **Svelte 5 UI:** The interface has been rebuilt for better responsiveness and clearer status indicators.
+- **Security:** All data remains end-to-end encrypted. Even the signalling relay never sees your actual notes.
+

docs/troubleshooting.md

@@ -255,14 +255,20 @@ It depends on Obsidian detects. May toggling `Detect all extensions` of
 
 ### I hope to report the issue, but you said you needs `Report`. How to make it?
 
-We can copy the report to the clipboard, by pressing the `Make report` button on
-the `Hatch` pane. ![Screenshot](../images/hatch.png)
+We can copy the report to the clipboard, by performing 
+`Generate full report for opening the issue with debug info` command!
 
 ### Where can I check the log?
 
 We can launch the log pane by `Show log` on the command palette. And if you have
 troubled something, please enable the `Verbose Log` on the `General Setting`
 pane.
+`Generate full report for opening the issue with debug info` command also contains 
+the recent 1000 log lines, which is very helpful for debugging. Full-report is 
+already set to the verbose level, so it contains all the logs without enabling the 
+`Verbose Log` toggle.
+
+Let me note that please be sure to remove any sensitive information before sharing the report.
 
 However, the logs would not be kept so long and cleared when restarted. If you
 want to check the logs, please enable `Write logs into the file` temporarily.

esbuild.config.mjs

@@ -2,7 +2,6 @@
 
 import esbuild from "esbuild";
 import process from "process";
-import builtins from "builtin-modules";
 import sveltePlugin from "esbuild-svelte";
 import { sveltePreprocess } from "svelte-preprocess";
 import fs from "node:fs";

eslint.config.mjs

@@ -1,102 +1,134 @@
-import typescriptEslint from "@typescript-eslint/eslint-plugin";
-import svelte from "eslint-plugin-svelte";
-import _import from "eslint-plugin-import";
-import { fixupPluginRules } from "@eslint/compat";
 import tsParser from "@typescript-eslint/parser";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import js from "@eslint/js";
-import { FlatCompat } from "@eslint/eslintrc";
+import obsidianmd from "eslint-plugin-obsidianmd";
+import globals from "globals";
+import { defineConfig, globalIgnores } from "eslint/config";
+import * as sveltePlugin from "eslint-plugin-svelte";
+import svelteParser from "svelte-eslint-parser";
+const warnWhileDev = "off"; // Change to "warn" to enable warnings for rules that are currently disabled.
+export default defineConfig([
+    globalIgnores([
+        // Build outputs and legacy files
+        "**/build",
+        "coverage",
+        "**/main.js",
+        "main_org.js",
+        "pouchdb-browser.js",
+        "version-bump.mjs",
+        "package.json",
+        "**/*.json",
+        "**/.eslintrc.js.bak",
+        // Files from linked dependencies (those files should not exist for most people).
+        "modules/octagonal-wheels/dist/**/*",
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const compat = new FlatCompat({
-    baseDirectory: __dirname,
-    recommendedConfig: js.configs.recommended,
-    allConfig: js.configs.all,
-});
+        // Sub-projects (Exclude from root linting as they have different environments)
+        "src/apps/**/*",
+        "utils/**/*",
 
-export default [
+        // Specific exclusions from common library (src/lib)
+        "src/lib/coverage",
+        "src/lib/browsertest",
+        "src/lib/test",
+        "src/lib/_tools",
+        "src/lib/src/patches/pouchdb-utils",
+        "src/lib/src/cli",
+        "src/lib/src/services/implements/browser/**",
+        "src/lib/src/services/implements/headless/**",
+        "src/lib/src/API",
+
+        // Config files and build scripts
+        "**/jest.config.js",
+        "**/rollup.config.js",
+        "**/esbuild.config.mjs",
+        "**/terser.*.mjs",
+        ".prettierrc.*.mjs",
+        ".prettierrc.mjs",
+        "*.config.mjs",
+        "vite.*",
+        "vitest.*",
+        // Testing files (Simplified patterns)
+        "test/**",
+        "**/*.test.ts",
+        "**/*.unit.spec.ts",
+        "**/test.ts",
+        "**/tests.ts",
+    ]),
+    ...sveltePlugin.configs["flat/base"],
+    ...obsidianmd.configs.recommended,
     {
-        ignores: [
-            "**/node_modules/*",
-            "**/jest.config.js",
-            "src/lib/coverage",
-            "src/lib/browsertest",
-            "**/test.ts",
-            "**/tests.ts",
-            "**/**test.ts",
-            "**/**.test.ts",
-            "**/esbuild.*.mjs",
-            "**/terser.*.mjs",
-            "**/node_modules",
-            "**/build",
-            "**/.eslintrc.js.bak",
-            "src/lib/src/patches/pouchdb-utils",
-            "**/esbuild.config.mjs",
-            "**/rollup.config.js",
-            "modules/octagonal-wheels/rollup.config.js",
-            "modules/octagonal-wheels/dist/**/*",
-            "src/lib/test",
-            "src/lib/src/cli",
-            "**/main.js",
-            "src/apps/**/*",
-            ".prettierrc.*.mjs",
-            ".prettierrc.mjs",
-            "*.config.mjs"
-        ],
-    },
-    ...compat.extends(
-        "eslint:recommended",
-        "plugin:@typescript-eslint/eslint-recommended",
-        "plugin:@typescript-eslint/recommended"
-    ),
-    {
-        plugins: {
-            "@typescript-eslint": typescriptEslint,
-            svelte,
-            import: fixupPluginRules(_import),
-        },
-
+        files: ["**/*.ts"],
+        // ignores:["src/lib/**/*.ts"], // Exclude library files from root linting (they have different environments and rules).
         languageOptions: {
+            globals: { ...globals.browser, PouchDB: "readonly" },
             parser: tsParser,
-            ecmaVersion: 5,
-            sourceType: "module",
-
             parserOptions: {
-                project: ["tsconfig.json"],
+                project: "./tsconfig.json",
             },
         },
-
+        linterOptions:{
+            reportUnusedDisableDirectives: false,
+        },
         rules: {
+            // -- Base rules (turned off in favour of TS specific versions or explicitly disabled).
             "no-unused-vars": "off",
-
-            "@typescript-eslint/no-unused-vars": [
-                "error",
-                {
-                    args: "none",
-                },
-            ],
-
             "no-unused-labels": "off",
-            "@typescript-eslint/ban-ts-comment": "off",
             "no-prototype-builtins": "off",
-            "@typescript-eslint/no-empty-function": "off",
-            "require-await": "error",
-            "@typescript-eslint/require-await": "warn",
-            "@typescript-eslint/no-misused-promises": "warn",
-            "@typescript-eslint/no-floating-promises": "warn",
-            "no-async-promise-executor": "warn",
+            "require-await": "off",
+            // -- TypeScript specific rules
+            //  @typescript-eslint/no-unsafe-* rules and @typescript-eslint/no-explicit-any:
+            //  This project contains a lot of library-sh code where the use of `any` is often necessary and justified.
+            //  Rules is now set to 'off' for a while.
             "@typescript-eslint/no-explicit-any": "off",
+            "@typescript-eslint/no-unsafe-argument": "off",
+            "@typescript-eslint/no-unsafe-call": "off",
+            "@typescript-eslint/no-unsafe-member-access": "off",
+            "@typescript-eslint/no-unsafe-return": "off",
+            "@typescript-eslint/no-unsafe-assignment": "off",
+            // -- Reasonable rules.
+            "@typescript-eslint/no-deprecated": warnWhileDev,
+            "@typescript-eslint/no-unused-vars": ["error", { args: "none" }],
+            "@typescript-eslint/ban-ts-comment": "off",
+            "@typescript-eslint/no-empty-function": "off",
+            "@typescript-eslint/require-await": "error",
+            "@typescript-eslint/no-misused-promises": "error",
+            "@typescript-eslint/no-floating-promises": "error",
             "@typescript-eslint/no-unnecessary-type-assertion": "error",
 
-            "no-constant-condition": [
-                "error",
-                {
-                    checkLoops: false,
-                },
-            ],
+            // -- Obsidian rules
+            // obsidianmd/no-unsupported-api: usually this project checks for API support at runtime, so this rule is not critical but can be helpful to catch potential issues.
+            "obsidianmd/no-unsupported-api": warnWhileDev,
+
+            // -- General rules
+            "no-async-promise-executor": warnWhileDev,
+            "no-constant-condition": ["error", { checkLoops: false }],
+            // -- Disabled rules
+            // no-undef: This option breaks the global declarations for the library files and is not worth the effort to fix at this time.
+            "no-undef": "off",
+
+            // -- Plugin specific overrides
+            "obsidianmd/rule-custom-message": "off",
+            "obsidianmd/ui/sentence-case": "off",
+            "obsidianmd/no-plugin-as-component": "off",
+
+            // -- Temporary overrides for migration
+            "obsidianmd/no-static-styles-assignment": "off",
         },
     },
-];
-
+    {
+        files: ["**/*.svelte"],
+        languageOptions: {
+            parser: svelteParser,
+            parserOptions: {
+                parser: tsParser,
+                extraFileExtensions: [".svelte"],
+            },
+        },
+        rules: {
+            // no-unused-vars:
+            // Svelte template's declarations have a lot of false positives and the rule is not worth the effort to fix at this time.
+            // it may improve in the future with some options as like   ["error", { argsIgnorePattern: "^_", varsIgnorePattern: "^_" }],]
+            "no-unused-vars": "off",
+            "obsidianmd/no-plugin-as-component": "off",
+            "obsidianmd/ui/sentence-case": "off",
+        },
+    },
+]);

manifest.json

@@ -1,8 +1,8 @@
 {
     "id": "obsidian-livesync",
     "name": "Self-hosted LiveSync",
-    "version": "0.25.60",
-    "minAppVersion": "0.9.12",
+    "version": "0.25.70-patch1",
+    "minAppVersion": "1.7.2",
     "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",
     "authorUrl": "https://github.com/vrtmrz",

package.json

@@ -1,6 +1,6 @@
 {
     "name": "obsidian-livesync",
-    "version": "0.25.60",
+    "version": "0.25.70-patch1",
     "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",
@@ -19,13 +19,13 @@
         "buildVite": "npx dotenv-cli -e .env  -- vite build --mode production",
         "buildViteOriginal": "npx dotenv-cli -e .env  -- vite build --mode original",
         "buildDev": "node esbuild.config.mjs dev",
-        "lint": "eslint src",
+        "lint": "eslint --cache --concurrency auto src",
         "svelte-check": "svelte-check --tsconfig ./tsconfig.json",
         "tsc-check": "tsc --noEmit",
         "pretty": "npm run prettyNoWrite -- --write --log-level error",
         "prettyCheck": "npm run prettyNoWrite -- --check",
         "prettyNoWrite": "prettier --config ./.prettierrc.mjs \"**/*.js\" \"**/*.ts\" \"**/*.json\" ",
-        "check": "npm run lint && npm run svelte-check",
+        "check": "npm run tsc-check && npm run lint && npm run svelte-check",
         "unittest": "deno test -A --no-check --coverage=cov_profile  --v8-flags=--expose-gc  --trace-leaks  ./src/",
         "test": "vitest run",
         "test:unit": "vitest run --config vitest.config.unit.ts",
@@ -54,21 +54,21 @@
         "test:docker-all:start": "npm run test:docker-all:up && sleep 5 && npm run test:docker-all:init",
         "test:docker-all:stop": "npm run test:docker-all:down",
         "test:full": "npm run test:docker-all:start && vitest run --coverage && npm run test:docker-all:stop",
-        "test:p2p": "bash test/suitep2p/run-p2p-tests.sh"
+        "test:p2p": "bash test/suitep2p/run-p2p-tests.sh",
+        "version": "node version-bump.mjs && git add manifest.json versions.json"
     },
     "keywords": [],
     "author": "vorotamoroz",
     "license": "MIT",
     "devDependencies": {
         "@chialab/esbuild-plugin-worker": "^0.19.0",
-        "@eslint/compat": "^2.0.2",
-        "@eslint/eslintrc": "^3.3.4",
         "@eslint/js": "^9.39.3",
         "@sveltejs/vite-plugin-svelte": "^6.2.4",
         "@tsconfig/svelte": "^5.0.8",
         "@types/deno": "^2.5.0",
         "@types/diff-match-patch": "^1.0.36",
         "@types/markdown-it": "^14.1.2",
+        "@types/micromatch": "^4.0.10",
         "@types/node": "^24.10.13",
         "@types/pouchdb": "^6.4.2",
         "@types/pouchdb-adapter-http": "^6.1.6",
@@ -83,18 +83,15 @@
         "@vitest/browser": "^4.1.1",
         "@vitest/browser-playwright": "^4.1.1",
         "@vitest/coverage-v8": "^4.1.1",
-        "builtin-modules": "5.0.0",
-        "dotenv": "^17.3.1",
         "dotenv-cli": "^11.0.0",
         "esbuild": "0.25.0",
         "esbuild-plugin-inline-worker": "^0.1.1",
         "esbuild-svelte": "^0.9.4",
         "eslint": "^9.39.3",
-        "eslint-plugin-import": "^2.32.0",
+        "eslint-plugin-obsidianmd": "^0.3.0",
         "eslint-plugin-svelte": "^3.15.0",
         "events": "^3.3.0",
-        "glob": "^13.0.6",
-        "obsidian": "^1.12.3",
+        "globals": "^14.0.0",
         "playwright": "^1.58.2",
         "postcss": "^8.5.6",
         "postcss-load-config": "^6.0.1",
@@ -115,6 +112,7 @@
         "svelte-check": "^4.4.3",
         "svelte-preprocess": "^6.0.3",
         "terser": "^5.39.0",
+        "tinyglobby": "^0.2.15",
         "transform-pouch": "^2.0.0",
         "tslib": "^2.8.1",
         "tsx": "^4.21.0",
@@ -132,17 +130,21 @@
         "@smithy/middleware-apply-body-checksum": "^4.3.9",
         "@smithy/protocol-http": "^5.3.9",
         "@smithy/querystring-builder": "^4.2.9",
-        "@trystero-p2p/nostr": "^0.23.0",
+        "@smithy/util-retry": "^4.4.5",
+        "@trystero-p2p/nostr": "^0.24.0",
+        "chokidar": "^4.0.0",
         "commander": "^14.0.3",
         "diff-match-patch": "^1.0.5",
         "fflate": "^0.8.2",
         "idb": "^8.0.3",
         "markdown-it": "^14.1.1",
+        "micromatch": "^4.0.0",
         "minimatch": "^10.2.2",
-        "octagonal-wheels": "^0.1.45",
+        "obsidian": "^1.12.3",
+        "octagonal-wheels": "^0.1.46",
         "pouchdb-adapter-leveldb": "^9.0.0",
         "qrcode-generator": "^1.4.4",
-        "werift": "^0.22.9",
+        "werift": "^0.23.0",
         "xxhash-wasm-102": "npm:xxhash-wasm@^1.0.2"
     }
 }

src/LiveSyncBaseCore.ts

@@ -1,4 +1,5 @@
 import { LOG_LEVEL_INFO } from "octagonal-wheels/common/logger";
+import type PouchDB from "pouchdb-core";
 import type { SimpleStore } from "octagonal-wheels/databases/SimpleStoreBase";
 import type { HasSettings, ObsidianLiveSyncSettings, EntryDoc } from "./lib/src/common/types";
 import { __$checkInstanceBinding } from "./lib/src/dev/checks";
@@ -123,7 +124,7 @@ export class LiveSyncBaseCore<
         for (const module of this.modules) {
             if (module.constructor === constructor) return module as T;
         }
-        throw new Error(`Module ${constructor} not found or not loaded.`);
+        throw new Error(`Module ${constructor.name} not found or not loaded.`);
     }
 
     /**
@@ -160,8 +161,10 @@ export class LiveSyncBaseCore<
                 module.onBindFunction(this, this.services);
                 __$checkInstanceBinding(module); // Check if all functions are properly bound, and log warnings if not.
             } else {
+                // module should not be never.
+                const moduleName = (module as unknown)?.constructor?.name ?? "unknown";
                 this.services.API.addLog(
-                    `Module ${(module as any)?.constructor?.name ?? "unknown"} does not have onBindFunction, skipping binding.`,
+                    `Module ${moduleName} does not have onBindFunction, skipping binding.`,
                     LOG_LEVEL_INFO
                 );
             }

src/apps/cli/.gitignore

@@ -3,4 +3,6 @@ test/*
 !test/*.sh
 test/test-init.local.sh
 node_modules
-.*.json
+.*.json
+*.env
+!.test.env

src/apps/cli/Dockerfile

@@ -60,7 +60,7 @@ RUN apt-get update \
 WORKDIR /build
 
 # Install workspace dependencies first (layer-cache friendly)
-COPY package.json ./
+COPY package.json package-lock.json ./
 RUN npm install
 
 # Copy the full source tree and build the CLI bundle

src/apps/cli/README.md

@@ -74,6 +74,12 @@ livesync-cli [database-path] [command] [args...]
 - `pull <src> <dst>`: Pull a file `<src>` from the database into local file `<dst>`.
 - `cat <src>`: Read a file from the database and write to stdout.
 - `put <dst>`: Read from stdin and write to the database path `<dst>`.
+- `remote-add <name> <connstr>`: Add a remote configuration from a connection string.
+- `remote-rm <remote-id>`: Remove a remote configuration by ID.
+- `remote-ls`: List remote configurations (`id`, `name`, `active/inactive`, redacted URI).
+- `remote-export <remote-id>`: Export the stored connection string by remote ID.
+- `remote-set <remote-id> <connstr>`: Replace the stored connection string by remote ID.
+- `remote-activate <remote-id>`: Activate a remote configuration by ID.
 - `init-settings [file]`: Create a default settings file.
 
 ### Examples
@@ -95,13 +101,24 @@ livesync-cli ./my-db pull folder/note.md ./note.md
 ### Build from source
 
 ```bash
-# Install dependencies (ensure you are in repository root directory, not src/apps/cli)
-# due to shared dependencies with webapp and main library
+# Clone with submodules, because the shared core lives in src/lib
+git clone --recurse-submodules <repository-url>
+cd obsidian-livesync
+
+# If you already cloned without submodules, run this once instead
+git submodule update --init --recursive
+
+# Install dependencies from the repository root
 npm install
-# Build the project (ensure you are in `src/apps/cli` directory)
+
+# Build the CLI from its package directory
+cd src/apps/cli
 npm run build
 ```
 
+If `src/lib` is missing, `npm run build` now stops early with a targeted message
+instead of a low-level Vite `ENOENT` error.
+
 Run the CLI:
 
 ```bash
@@ -241,6 +258,14 @@ livesync-cli /path/to/your-local-database --settings /path/to/settings.json rm /
 
 # Resolve conflict by keeping a specific revision
 livesync-cli /path/to/your-local-database --settings /path/to/settings.json resolve /vault/path/file.md 3-abcdef
+
+# Add/list/activate/remove remote configurations
+livesync-cli /path/to/your-local-database --settings /path/to/settings.json remote-add main "sls+https://user:pass@example.com/db"
+livesync-cli /path/to/your-local-database --settings /path/to/settings.json remote-ls
+livesync-cli /path/to/your-local-database --settings /path/to/settings.json remote-export remote-abc123
+livesync-cli /path/to/your-local-database --settings /path/to/settings.json remote-set remote-abc123 "sls+p2p://room-abc?passphrase=secret"
+livesync-cli /path/to/your-local-database --settings /path/to/settings.json remote-activate remote-abc123
+livesync-cli /path/to/your-local-database --settings /path/to/settings.json remote-rm remote-abc123
 ```
 
 ### Configuration
@@ -286,9 +311,11 @@ Options:
   --force, -f             Overwrite existing file on init-settings
   --verbose, -v           Enable verbose logging
   --debug, -d             Enable debug logging (includes verbose)
-  --help, -h              Show help message
+  --interval <N>, -i <N>  (daemon only) Poll CouchDB every N seconds instead of using the _changes feed
+  --help, -h              Show this help message
 
 Commands:
+  daemon                  (default) Run mirror scan then continuously sync CouchDB <-> local filesystem
   init-settings [path]    Create settings JSON from DEFAULT_SETTINGS
   sync                    Run one replication cycle and exit
   p2p-peers <timeout>     Show discovered peers as [peer]<TAB><peer-id><TAB><peer-name>
@@ -395,6 +422,86 @@ In other words, it performs the following actions:
 
 Note: `mirror` does not respect file deletions. If a file is deleted in storage, it will be restored on the next `mirror` run. To delete a file, use the `rm` command instead. This is a little inconvenient, but it is intentional behaviour (if we handle this automatically in `mirror`, we should be against a ton of edge cases).
 
+##### daemon
+
+`daemon` is the default command when no command is specified. It runs an initial mirror scan and then continuously syncs changes in both directions:
+
+- **CouchDB → local filesystem**: via the `_changes` feed (LiveSync mode, default) or periodic polling (`--interval N`).
+- **local filesystem → CouchDB**: via chokidar file watching. Any file created, modified, or deleted in the vault directory is pushed to CouchDB.
+
+In **LiveSync mode** the `_changes` feed delivers remote changes as they arrive, with sub-second latency. In **polling mode** (`--interval N`) the CLI polls CouchDB every N seconds. Use polling mode if your CouchDB instance does not support long-lived HTTP connections, or if you need predictable network usage.
+
+The daemon exits cleanly on `SIGINT` or `SIGTERM`.
+
+```bash
+# LiveSync mode (default — _changes feed, near-real-time)
+livesync-cli /path/to/vault
+
+# Polling mode — poll every 60 seconds
+livesync-cli /path/to/vault --interval 60
+```
+
+### .livesync/ignore
+
+Place a `.livesync/ignore` file in your vault root to exclude files from sync in both directions (local → CouchDB and CouchDB → local).
+
+**Format:**
+
+- Lines beginning with `#` are comments.
+- Blank lines are ignored.
+- All other lines are [minimatch](https://github.com/isaacs/minimatch) glob patterns, relative to the vault root.
+- The directive `import: .gitignore` (exactly this string) reads `.gitignore` from the vault root and merges its non-comment, non-blank lines into the ignore rules.
+- Negation patterns (lines starting with `!`) are not supported and will cause an error on load.
+
+**Example `.livesync/ignore`:**
+
+```
+# Ignore temporary files
+*.tmp
+*.swp
+
+# Ignore build output
+build/
+dist/
+
+# Merge patterns from .gitignore
+import: .gitignore
+```
+
+Patterns apply in both directions: the chokidar watcher will not emit events for matched files, and the `isTargetFile` filter will exclude them from CouchDB → local sync.
+
+Changes to this file require a daemon restart to take effect.
+
+### Systemd Installation
+
+The `deploy/` directory contains a systemd unit template and an install script.
+
+**Automated install (user service, recommended):**
+
+```bash
+bash src/apps/cli/deploy/install.sh --vault /path/to/vault
+```
+
+**With polling interval:**
+
+```bash
+bash src/apps/cli/deploy/install.sh --vault /path/to/vault --interval 60
+```
+
+**System-wide install** (requires root / sudo for `/etc/systemd/system/`):
+
+```bash
+bash src/apps/cli/deploy/install.sh --system --vault /path/to/vault
+```
+
+The script:
+1. Builds the CLI (`npm install` + `npm run build`).
+2. Installs the binary to `~/.local/bin/livesync-cli` (user) or `/usr/local/bin/livesync-cli` (system).
+3. Writes the unit file to `~/.config/systemd/user/livesync-cli.service` (user) or `/etc/systemd/system/livesync-cli.service` (system).
+4. Runs `systemctl [--user] daemon-reload && systemctl [--user] enable --now livesync-cli`.
+
+**Manual setup** — if you prefer to manage the unit yourself, copy `deploy/livesync-cli.service`, replace `LIVESYNC_BIN` and `LIVESYNC_VAULT_PATH` with the actual binary path and vault path, then install to the appropriate systemd directory.
+
 ### Planned options:
 
 - `--immediate`: Perform sync after the command (e.g. `push`, `pull`, `put`, `rm`).

src/apps/cli/adapters/NodeFileSystemAdapter.ts

@@ -39,12 +39,6 @@ export class NodeFileSystemAdapter implements IFileSystemAdapter<NodeFile, NodeF
 
     async getAbstractFileByPath(p: FilePath | string): Promise<NodeFile | null> {
         const pathStr = this.normalisePath(p);
-
-        const cached = this.fileCache.get(pathStr);
-        if (cached) {
-            return cached;
-        }
-
         return await this.refreshFile(pathStr);
     }
 
@@ -104,14 +98,15 @@ export class NodeFileSystemAdapter implements IFileSystemAdapter<NodeFile, NodeF
                 path: pathStr as FilePath,
                 stat: {
                     size: stat.size,
-                    mtime: stat.mtimeMs,
-                    ctime: stat.ctimeMs,
+                    mtime: Math.floor(stat.mtimeMs),
+                    ctime: Math.floor(stat.ctimeMs),
                     type: "file",
                 },
             };
             this.fileCache.set(pathStr, file);
             return file;
         } catch {
+            // Evict so a deleted file is not returned by subsequent cache scans.
             this.fileCache.delete(pathStr);
             return null;
         }
@@ -137,8 +132,8 @@ export class NodeFileSystemAdapter implements IFileSystemAdapter<NodeFile, NodeF
                         path: entryRelativePath as FilePath,
                         stat: {
                             size: stat.size,
-                            mtime: stat.mtimeMs,
-                            ctime: stat.ctimeMs,
+                            mtime: Math.floor(stat.mtimeMs),
+                            ctime: Math.floor(stat.ctimeMs),
                             type: "file",
                         },
                     };

src/apps/cli/adapters/NodeStorageAdapter.ts

@@ -28,8 +28,8 @@ export class NodeStorageAdapter implements IStorageAdapter<NodeStat> {
             const stat = await fs.stat(this.resolvePath(p));
             return {
                 size: stat.size,
-                mtime: stat.mtimeMs,
-                ctime: stat.ctimeMs,
+                mtime: Math.floor(stat.mtimeMs),
+                ctime: Math.floor(stat.ctimeMs),
                 type: stat.isDirectory() ? "folder" : "file",
             };
         } catch {

src/apps/cli/adapters/NodeVaultAdapter.ts

@@ -15,7 +15,12 @@ export class NodeVaultAdapter implements IVaultAdapter<NodeFile> {
     }
 
     async read(file: NodeFile): Promise<string> {
-        return await fs.readFile(this.resolvePath(file.path), "utf-8");
+        const content = await fs.readFile(this.resolvePath(file.path), "utf-8");
+        // Correct stale stat.size — chokidar stats may be from a poll before the final write.
+        // The downstream document integrity check compares stat.size to content length, so
+        // they must agree or other clients reject the file as corrupted.
+        file.stat.size = Buffer.byteLength(content, "utf-8");
+        return content;
     }
 
     async cachedRead(file: NodeFile): Promise<string> {
@@ -25,6 +30,8 @@ export class NodeVaultAdapter implements IVaultAdapter<NodeFile> {
 
     async readBinary(file: NodeFile): Promise<ArrayBuffer> {
         const buffer = await fs.readFile(this.resolvePath(file.path));
+        // Same correction as read() — ensure stat.size matches actual byte length.
+        file.stat.size = buffer.length;
         return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength) as ArrayBuffer;
     }
 
@@ -66,8 +73,8 @@ export class NodeVaultAdapter implements IVaultAdapter<NodeFile> {
             path: p as any,
             stat: {
                 size: stat.size,
-                mtime: stat.mtimeMs,
-                ctime: stat.ctimeMs,
+                mtime: Math.floor(stat.mtimeMs),
+                ctime: Math.floor(stat.ctimeMs),
                 type: "file",
             },
         };
@@ -89,8 +96,8 @@ export class NodeVaultAdapter implements IVaultAdapter<NodeFile> {
             path: p as any,
             stat: {
                 size: stat.size,
-                mtime: stat.mtimeMs,
-                ctime: stat.ctimeMs,
+                mtime: Math.floor(stat.mtimeMs),
+                ctime: Math.floor(stat.ctimeMs),
                 type: "file",
             },
         };

src/apps/cli/commands/daemonCommand.unit.spec.ts

@@ -0,0 +1,312 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
+import { runCommand } from "./runCommand";
+import type { CLIOptions } from "./types";
+
+// Mock performFullScan so daemon tests don't require a real CouchDB connection.
+vi.mock("@lib/serviceFeatures/offlineScanner", () => ({
+    performFullScan: vi.fn(async () => true),
+}));
+
+// Mock UnresolvedErrorManager to avoid event-hub side effects.
+vi.mock("@lib/services/base/UnresolvedErrorManager", () => ({
+    UnresolvedErrorManager: class UnresolvedErrorManager {
+        showError() {}
+        clearError() {}
+        clearErrors() {}
+    },
+}));
+
+import * as offlineScanner from "@lib/serviceFeatures/offlineScanner";
+
+function createCoreMock() {
+    return {
+        services: {
+            control: {
+                activated: Promise.resolve(),
+                applySettings: vi.fn(async () => {}),
+            },
+            setting: {
+                applyPartial: vi.fn(async () => {}),
+                currentSettings: vi.fn(() => ({ liveSync: true, syncOnStart: false })),
+            },
+            replication: {
+                replicate: vi.fn(async () => true),
+            },
+            appLifecycle: {
+                onUnload: {
+                    addHandler: vi.fn(),
+                },
+            },
+        },
+        serviceModules: {
+            fileHandler: {
+                dbToStorage: vi.fn(async () => true),
+                storeFileToDB: vi.fn(async () => true),
+            },
+            storageAccess: {
+                readFileAuto: vi.fn(async () => ""),
+                writeFileAuto: vi.fn(async () => {}),
+            },
+            databaseFileAccess: {
+                fetch: vi.fn(async () => undefined),
+            },
+        },
+    } as any;
+}
+
+function makeDaemonOptions(interval?: number): CLIOptions {
+    return {
+        command: "daemon",
+        commandArgs: [],
+        databasePath: "/tmp/vault",
+        verbose: false,
+        force: false,
+        interval,
+    };
+}
+
+const baseContext = {
+    vaultPath: "/tmp/vault",
+    settingsPath: "/tmp/vault/.livesync/settings.json",
+    originalSyncSettings: {
+        liveSync: true,
+        syncOnStart: false,
+        periodicReplication: false,
+        syncOnSave: false,
+        syncOnEditorSave: false,
+        syncOnFileOpen: false,
+        syncAfterMerge: false,
+    },
+} as any;
+
+describe("daemon command", () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+        vi.useFakeTimers();
+    });
+
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+
+    it("calls performFullScan during startup", async () => {
+        const core = createCoreMock();
+        vi.mocked(offlineScanner.performFullScan).mockResolvedValue(true);
+
+        await runCommand(makeDaemonOptions(), { ...baseContext, core });
+
+        expect(offlineScanner.performFullScan).toHaveBeenCalledTimes(1);
+    });
+
+    it("returns false when performFullScan fails", async () => {
+        const core = createCoreMock();
+        vi.mocked(offlineScanner.performFullScan).mockResolvedValue(false);
+
+        const result = await runCommand(makeDaemonOptions(), { ...baseContext, core });
+
+        expect(result).toBe(false);
+    });
+
+    it("polling mode: calls setTimeout when interval option is set", async () => {
+        const core = createCoreMock();
+        vi.mocked(offlineScanner.performFullScan).mockResolvedValue(true);
+        const setTimeoutSpy = vi.spyOn(globalThis, "setTimeout");
+
+        await runCommand(makeDaemonOptions(30), { ...baseContext, core });
+
+        expect(setTimeoutSpy).toHaveBeenCalledTimes(1);
+        // Interval should be in milliseconds (30s → 30000ms)
+        expect(setTimeoutSpy).toHaveBeenCalledWith(expect.any(Function), 30000);
+    });
+
+    it("polling mode: applies settings with suspendFileWatching=false before setting interval", async () => {
+        const core = createCoreMock();
+        vi.mocked(offlineScanner.performFullScan).mockResolvedValue(true);
+
+        await runCommand(makeDaemonOptions(10), { ...baseContext, core });
+
+        expect(core.services.setting.applyPartial).toHaveBeenCalledWith(
+            expect.objectContaining({ suspendFileWatching: false }),
+            true
+        );
+        expect(core.services.control.applySettings).toHaveBeenCalledTimes(1);
+    });
+
+    it("liveSync mode: calls applyPartial and applySettings", async () => {
+        const core = createCoreMock();
+        vi.mocked(offlineScanner.performFullScan).mockResolvedValue(true);
+
+        await runCommand(makeDaemonOptions(), { ...baseContext, core });
+
+        expect(core.services.setting.applyPartial).toHaveBeenCalledWith(
+            expect.objectContaining({
+                ...baseContext.originalSyncSettings,
+                suspendFileWatching: false,
+            }),
+            true
+        );
+        expect(core.services.control.applySettings).toHaveBeenCalledTimes(1);
+    });
+
+    it("liveSync mode: logs warning when both liveSync and syncOnStart are false", async () => {
+        const core = createCoreMock();
+        core.services.setting.currentSettings = vi.fn(() => ({
+            liveSync: false,
+            syncOnStart: false,
+        }));
+        vi.mocked(offlineScanner.performFullScan).mockResolvedValue(true);
+        const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+        const result = await runCommand(makeDaemonOptions(), { ...baseContext, core });
+
+        expect(result).toBe(true);
+        const warningCalls = consoleSpy.mock.calls.filter(
+            (args) => typeof args[0] === "string" && args[0].includes("liveSync and syncOnStart are both disabled")
+        );
+        expect(warningCalls.length).toBeGreaterThan(0);
+    });
+
+    it("liveSync mode: no warning when liveSync is true", async () => {
+        const core = createCoreMock();
+        core.services.setting.currentSettings = vi.fn(() => ({
+            liveSync: true,
+            syncOnStart: false,
+        }));
+        vi.mocked(offlineScanner.performFullScan).mockResolvedValue(true);
+        const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+        await runCommand(makeDaemonOptions(), { ...baseContext, core });
+
+        const warningCalls = consoleSpy.mock.calls.filter(
+            (args) => typeof args[0] === "string" && args[0].includes("liveSync and syncOnStart are both disabled")
+        );
+        expect(warningCalls.length).toBe(0);
+    });
+
+    it("calls replicate before performFullScan", async () => {
+        const core = createCoreMock();
+        const callOrder: string[] = [];
+        core.services.replication.replicate = vi.fn(async () => {
+            callOrder.push("replicate");
+            return true;
+        });
+        vi.mocked(offlineScanner.performFullScan).mockImplementation(async () => {
+            callOrder.push("performFullScan");
+            return true;
+        });
+
+        await runCommand(makeDaemonOptions(), { ...baseContext, core });
+
+        expect(callOrder).toEqual(["replicate", "performFullScan"]);
+    });
+
+    it("returns false when initial replication fails", async () => {
+        const core = createCoreMock();
+        core.services.replication.replicate = vi.fn(async () => false);
+        vi.mocked(offlineScanner.performFullScan).mockClear();
+
+        const result = await runCommand(makeDaemonOptions(), { ...baseContext, core });
+
+        expect(result).toBe(false);
+        // performFullScan should NOT have been called
+        expect(offlineScanner.performFullScan).not.toHaveBeenCalled();
+    });
+
+    it("polling mode: registers onUnload handler that clears timeout", async () => {
+        const core = createCoreMock();
+        vi.mocked(offlineScanner.performFullScan).mockResolvedValue(true);
+
+        await runCommand(makeDaemonOptions(10), { ...baseContext, core });
+
+        // onUnload handler should have been registered
+        expect(core.services.appLifecycle.onUnload.addHandler).toHaveBeenCalledTimes(1);
+        const handler = core.services.appLifecycle.onUnload.addHandler.mock.calls[0][0];
+
+        // Get the timeout ID that was created
+        const clearTimeoutSpy = vi.spyOn(globalThis, "clearTimeout");
+        await handler();
+        expect(clearTimeoutSpy).toHaveBeenCalledTimes(1);
+    });
+
+    it("polling backoff: interval escalates on failure, caps at 300000ms, then halves on recovery", async () => {
+        const core = createCoreMock();
+        vi.mocked(offlineScanner.performFullScan).mockResolvedValue(true);
+        vi.spyOn(console, "error").mockImplementation(() => {});
+
+        // startup replicate (call 1) succeeds; poll calls 2–7 fail; call 8 succeeds.
+        let callCount = 0;
+        core.services.replication.replicate = vi.fn(async () => {
+            callCount++;
+            if (callCount === 1) return true; // initial startup replicate
+            if (callCount <= 7) throw new Error("network failure");
+            return true; // recovery
+        });
+
+        const baseMs = 30 * 1000;
+        const setTimeoutSpy = vi.spyOn(globalThis, "setTimeout");
+
+        await runCommand(makeDaemonOptions(30), { ...baseContext, core });
+
+        // After runCommand returns the first setTimeout has been scheduled.
+        // setTimeoutSpy.mock.calls[0] is the initial schedule (baseMs).
+        expect(setTimeoutSpy.mock.calls[0][1]).toBe(baseMs);
+
+        // Advance through 6 failure polls. After each failure the next setTimeout
+        // should be scheduled with a larger (or capped) interval.
+        // formula: min(base * 2^n, 300000). base=30000ms.
+        // failure 1: 30000*2=60000, failure 2: 30000*4=120000,
+        // failure 3: 30000*8=240000, failure 4: 30000*16=480000→capped, 5→cap, 6→cap
+        const expectedIntervals = [
+            baseMs * 2, // after failure 1: 60000
+            baseMs * 4, // after failure 2: 120000
+            baseMs * 8, // after failure 3: 240000
+            300_000, // after failure 4 (would be 480000, capped)
+            300_000, // after failure 5 (cap)
+            300_000, // after failure 6 (cap)
+        ];
+
+        for (const expected of expectedIntervals) {
+            const prevCallCount = setTimeoutSpy.mock.calls.length;
+            await vi.advanceTimersByTimeAsync(setTimeoutSpy.mock.calls[prevCallCount - 1][1] as number);
+            const newCallCount = setTimeoutSpy.mock.calls.length;
+            expect(newCallCount).toBeGreaterThan(prevCallCount);
+            expect(setTimeoutSpy.mock.calls[newCallCount - 1][1]).toBe(expected);
+        }
+
+        // Now trigger the success poll — interval should halve each time toward base.
+        // After failure 6, consecutiveFailures=6, currentIntervalMs=300000.
+        // On success: consecutiveFailures=5, currentIntervalMs=150000.
+        const prevCallCount = setTimeoutSpy.mock.calls.length;
+        await vi.advanceTimersByTimeAsync(setTimeoutSpy.mock.calls[prevCallCount - 1][1] as number);
+        const afterSuccessCallCount = setTimeoutSpy.mock.calls.length;
+        expect(afterSuccessCallCount).toBeGreaterThan(prevCallCount);
+        // The interval after one success should be halved (300000 / 2 = 150000).
+        expect(setTimeoutSpy.mock.calls[afterSuccessCallCount - 1][1]).toBe(150_000);
+    });
+
+    it("polling error handling: replicate rejection is caught and console.error is called", async () => {
+        const core = createCoreMock();
+        vi.mocked(offlineScanner.performFullScan).mockResolvedValue(true);
+        const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+        // Make replicate succeed on the initial call (startup), then fail on the poll.
+        let callCount = 0;
+        core.services.replication.replicate = vi.fn(async () => {
+            callCount++;
+            if (callCount === 1) return true; // startup replicate
+            throw new Error("network failure");
+        });
+
+        const intervalMs = 30 * 1000;
+        await runCommand(makeDaemonOptions(30), { ...baseContext, core });
+
+        // Advance time to trigger the first poll callback and flush its async work.
+        await vi.advanceTimersByTimeAsync(intervalMs);
+
+        // No unhandled rejection — the error was caught internally.
+        const errorCalls = consoleSpy.mock.calls.filter(
+            (args) => typeof args[0] === "string" && args[0].includes("Poll error")
+        );
+        expect(errorCalls.length).toBeGreaterThan(0);
+    });
+});

src/apps/cli/commands/p2p.ts

@@ -32,10 +32,15 @@ function validateP2PSettings(core: LiveSyncBaseCore<ServiceContext, any>) {
     settings.P2P_IsHeadless = true;
 }
 
-function createReplicator(core: LiveSyncBaseCore<ServiceContext, any>): LiveSyncTrysteroReplicator {
+async function createReplicator(core: LiveSyncBaseCore<ServiceContext, any>): Promise<LiveSyncTrysteroReplicator> {
     validateP2PSettings(core);
-    const replicator = new LiveSyncTrysteroReplicator({ services: core.services });
-    addP2PEventHandlers(replicator);
+    const replicator = await core.services.replicator.getNewReplicator();
+    if (!replicator) {
+        throw new Error("Failed to create replicator instance. Ensure P2P is enabled in settings.");
+    }
+    if (!(replicator instanceof LiveSyncTrysteroReplicator)) {
+        throw new Error("Unexpected replicator type. Expected LiveSyncTrysteroReplicator.");
+    }
     return replicator;
 }
 
@@ -49,7 +54,7 @@ export async function collectPeers(
     core: LiveSyncBaseCore<ServiceContext, any>,
     timeoutSec: number
 ): Promise<CLIP2PPeer[]> {
-    const replicator = createReplicator(core);
+    const replicator = await createReplicator(core);
     await replicator.open();
     try {
         await delay(timeoutSec * 1000);
@@ -79,7 +84,7 @@ export async function syncWithPeer(
     peerToken: string,
     timeoutSec: number
 ): Promise<CLIP2PPeer> {
-    const replicator = createReplicator(core);
+    const replicator = await createReplicator(core);
     await replicator.open();
     try {
         const timeoutMs = timeoutSec * 1000;
@@ -115,7 +120,7 @@ export async function syncWithPeer(
 }
 
 export async function openP2PHost(core: LiveSyncBaseCore<ServiceContext, any>): Promise<LiveSyncTrysteroReplicator> {
-    const replicator = createReplicator(core);
+    const replicator = await createReplicator(core);
     await replicator.open();
     return replicator;
 }

src/apps/cli/commands/runCommand.ts

@@ -3,6 +3,8 @@ import * as path from "path";
 import { decodeSettingsFromSetupURI } from "@lib/API/processSetting";
 import { configURIBase } from "@lib/common/models/shared.const";
 import { DEFAULT_SETTINGS, type FilePathWithPrefix, type ObsidianLiveSyncSettings } from "@lib/common/types";
+import { ConnectionStringParser } from "@lib/common/ConnectionString";
+import { activateRemoteConfiguration, createRemoteConfigurationId } from "@lib/serviceFeatures/remoteConfig";
 import { stripAllPrefixes } from "@lib/string_and_binary/path";
 import type { CLICommandContext, CLIOptions } from "./types";
 import { promptForPassphrase, readStdinAsUtf8, toArrayBuffer, toDatabaseRelativePath } from "./utils";
@@ -10,11 +12,115 @@ import { collectPeers, openP2PHost, parseTimeoutSeconds, syncWithPeer } from "./
 import { performFullScan } from "@lib/serviceFeatures/offlineScanner";
 import { UnresolvedErrorManager } from "@lib/services/base/UnresolvedErrorManager";
 
+function redactConnectionString(uri: string): string {
+    return uri.replace(/\/\/([^@/]+)@/u, "//***@");
+}
+
 export async function runCommand(options: CLIOptions, context: CLICommandContext): Promise<boolean> {
     const { databasePath, core, settingsPath } = context;
 
     await core.services.control.activated;
     if (options.command === "daemon") {
+        const log = (msg: unknown) => console.error(`[Daemon] ${msg}`);
+
+        // Skip the config mismatch dialog — the daemon cannot resolve it interactively
+        // and the default "Dismiss" action would block replication. The daemon should
+        // accept whatever configuration the remote has.
+        await core.services.setting.applyPartial({ disableCheckingConfigMismatch: true }, true);
+
+        // 1. Replicate CouchDB → local PouchDB so the mirror scan has content to work with.
+        log("Replicating from CouchDB...");
+        const replResult = await core.services.replication.replicate(true);
+        if (!replResult) {
+            console.error("[Daemon] Initial CouchDB replication failed, cannot continue");
+            return false;
+        }
+        log("CouchDB replication complete");
+
+        // 2. Mirror scan to reconcile PouchDB ↔ local filesystem.
+        const errorManager = new UnresolvedErrorManager(core.services.appLifecycle);
+        log("Running mirror scan...");
+        const scanOk = await performFullScan(core as any, log, errorManager, false, true);
+        if (!scanOk) {
+            console.error("[Daemon] Mirror scan failed, cannot continue");
+            return false;
+        }
+        log("Mirror scan complete");
+
+        // 3. Re-enable sync.
+        const restoreSyncSettings = async () => {
+            await core.services.setting.applyPartial(
+                {
+                    ...context.originalSyncSettings,
+                    suspendFileWatching: false,
+                },
+                true
+            );
+            // applySettings fires the full lifecycle: onSuspending → onResumed.
+            // ModuleReplicatorCouchDB starts continuous replication on onResumed
+            // via fireAndForget.
+            await core.services.control.applySettings();
+            // Lifecycle events (onSuspending) may re-enable suspension flags.
+            // Clear them explicitly after the lifecycle completes. applyPartial
+            // with true is a direct store write — it does not re-trigger lifecycle.
+            await core.services.setting.applyPartial(
+                {
+                    suspendFileWatching: false,
+                    suspendParseReplicationResult: false,
+                },
+                true
+            );
+        };
+        if (options.interval) {
+            log(`Polling mode: syncing every ${options.interval}s`);
+            await restoreSyncSettings();
+            const baseIntervalMs = options.interval * 1000;
+            let currentIntervalMs = baseIntervalMs;
+            let consecutiveFailures = 0;
+            const maxIntervalMs = 5 * 60 * 1000; // 5 minutes cap
+
+            const poll = async () => {
+                try {
+                    await core.services.replication.replicate(true);
+                    if (consecutiveFailures > 0) {
+                        consecutiveFailures--;
+                        currentIntervalMs = Math.max(currentIntervalMs / 2, baseIntervalMs);
+                        log(`Replication recovered`);
+                    }
+                } catch (err) {
+                    consecutiveFailures++;
+                    currentIntervalMs = Math.min(baseIntervalMs * Math.pow(2, consecutiveFailures), maxIntervalMs);
+                    console.error(`[Daemon] Poll error (${consecutiveFailures} consecutive):`, err);
+                    if (consecutiveFailures >= 5) {
+                        console.error(
+                            `[Daemon] Warning: ${consecutiveFailures} consecutive failures, backing off to ${Math.round(currentIntervalMs / 1000)}s`
+                        );
+                    }
+                }
+                pollTimer = setTimeout(poll, currentIntervalMs);
+            };
+            let pollTimer: ReturnType<typeof setTimeout> = setTimeout(poll, currentIntervalMs);
+            core.services.appLifecycle.onUnload.addHandler(async () => {
+                clearTimeout(pollTimer);
+                return true;
+            });
+        } else {
+            log("LiveSync mode: restoring sync settings and starting _changes feed");
+            await restoreSyncSettings();
+            // The applySettings() lifecycle fires onResumed → ModuleReplicatorCouchDB which
+            // starts continuous replication via fireAndForget(openReplication). Don't call
+            // openReplication directly — it races with the handler and causes dedup/termination.
+            log("LiveSync active");
+            const currentSettings = core.services.setting.currentSettings();
+            if (!currentSettings.liveSync && !currentSettings.syncOnStart) {
+                console.error(
+                    "[Daemon] Warning: liveSync and syncOnStart are both disabled in settings. " +
+                        "No sync will occur. Set liveSync=true in your settings file for continuous sync, " +
+                        "or use --interval for polling mode."
+                );
+            }
+        }
+
         return true;
     }
 
@@ -83,8 +189,8 @@ export async function runCommand(options: CLIOptions, context: CLICommandContext
         console.log(`[Command] push ${sourcePath} -> ${destinationDatabasePath}`);
 
         await core.serviceModules.storageAccess.writeFileAuto(destinationDatabasePath, toArrayBuffer(sourceData), {
-            mtime: sourceStat.mtimeMs,
-            ctime: sourceStat.ctimeMs,
+            mtime: Math.floor(sourceStat.mtimeMs),
+            ctime: Math.floor(sourceStat.ctimeMs),
         });
         const destinationPathWithPrefix = destinationDatabasePath as FilePathWithPrefix;
         const stored = await core.serviceModules.fileHandler.storeFileToDB(destinationPathWithPrefix, true);
@@ -369,5 +475,206 @@ export async function runCommand(options: CLIOptions, context: CLICommandContext
         return await performFullScan(core as any, log, errorManager, false, true);
     }
 
+    if (options.command === "remote-add") {
+        if (options.commandArgs.length < 2) {
+            throw new Error("remote-add requires two arguments: <name> <connstr>");
+        }
+        const name = options.commandArgs[0].trim();
+        const connectionString = options.commandArgs[1].trim();
+        if (!name) {
+            throw new Error("remote-add requires a non-empty name");
+        }
+        if (!connectionString) {
+            throw new Error("remote-add requires a non-empty connection string");
+        }
+
+        const parsed = ConnectionStringParser.parse(connectionString);
+        const canonicalUri = ConnectionStringParser.serialize(parsed);
+        const id = createRemoteConfigurationId();
+        let activated = false;
+
+        await core.services.setting.updateSettings((currentSettings) => {
+            currentSettings.remoteConfigurations ||= {};
+            currentSettings.remoteConfigurations[id] = {
+                id,
+                name,
+                uri: canonicalUri,
+                isEncrypted: false,
+            };
+            if (!currentSettings.activeConfigurationId) {
+                currentSettings.activeConfigurationId = id;
+                const applied = activateRemoteConfiguration(currentSettings, id);
+                activated = applied !== false;
+            }
+            return currentSettings;
+        }, true);
+
+        if (activated) {
+            await core.services.control.applySettings();
+        }
+
+        process.stdout.write(`${id}\t${name}\t${redactConnectionString(canonicalUri)}\n`);
+        return true;
+    }
+
+    if (options.command === "remote-rm") {
+        if (options.commandArgs.length < 1) {
+            throw new Error("remote-rm requires one argument: <remote-id>");
+        }
+        const id = options.commandArgs[0].trim();
+        if (!id) {
+            throw new Error("remote-rm requires a non-empty remote-id");
+        }
+
+        const current = core.services.setting.currentSettings();
+        if (!current.remoteConfigurations?.[id]) {
+            process.stderr.write(`[Info] Remote configuration not found: ${id}\n`);
+            return false;
+        }
+
+        let switchedActive = false;
+        await core.services.setting.updateSettings((currentSettings) => {
+            const configs = currentSettings.remoteConfigurations || {};
+            delete configs[id];
+            currentSettings.remoteConfigurations = configs;
+
+            if (currentSettings.activeConfigurationId === id) {
+                const nextActiveId = Object.keys(configs)[0] || "";
+                currentSettings.activeConfigurationId = nextActiveId;
+                switchedActive = nextActiveId !== "";
+                if (nextActiveId !== "") {
+                    activateRemoteConfiguration(currentSettings, nextActiveId);
+                }
+            }
+
+            if (currentSettings.P2P_ActiveRemoteConfigurationId === id) {
+                currentSettings.P2P_ActiveRemoteConfigurationId = "";
+            }
+
+            return currentSettings;
+        }, true);
+
+        if (switchedActive) {
+            await core.services.control.applySettings();
+        }
+
+        console.error(`[Command] remote-rm ${id}`);
+        return true;
+    }
+
+    if (options.command === "remote-ls") {
+        const settings = core.services.setting.currentSettings();
+        const configs = Object.values(settings.remoteConfigurations || {});
+        configs.sort((a, b) => a.name.localeCompare(b.name));
+
+        if (configs.length === 0) {
+            process.stderr.write("[Info] No remote configurations found.\n");
+            return true;
+        }
+
+        const lines = configs.map((config) => {
+            const status = config.id === settings.activeConfigurationId ? "active" : "inactive";
+            return `${config.id}\t${config.name}\t${status}\t${redactConnectionString(config.uri)}`;
+        });
+        process.stdout.write(lines.join("\n") + "\n");
+        return true;
+    }
+
+    if (options.command === "remote-export") {
+        if (options.commandArgs.length < 1) {
+            throw new Error("remote-export requires one argument: <remote-id>");
+        }
+        const id = options.commandArgs[0].trim();
+        if (!id) {
+            throw new Error("remote-export requires a non-empty remote-id");
+        }
+
+        const config = core.services.setting.currentSettings().remoteConfigurations?.[id];
+        if (!config) {
+            process.stderr.write(`[Info] Remote configuration not found: ${id}\n`);
+            return false;
+        }
+
+        process.stdout.write(`${config.uri}\n`);
+        return true;
+    }
+
+    if (options.command === "remote-set") {
+        if (options.commandArgs.length < 2) {
+            throw new Error("remote-set requires two arguments: <remote-id> <connstr>");
+        }
+        const id = options.commandArgs[0].trim();
+        const connectionString = options.commandArgs[1].trim();
+        if (!id) {
+            throw new Error("remote-set requires a non-empty remote-id");
+        }
+        if (!connectionString) {
+            throw new Error("remote-set requires a non-empty connection string");
+        }
+
+        const parsed = ConnectionStringParser.parse(connectionString);
+        const canonicalUri = ConnectionStringParser.serialize(parsed);
+        let switchedActive = false;
+
+        await core.services.setting.updateSettings((currentSettings) => {
+            const config = currentSettings.remoteConfigurations?.[id];
+            if (!config) {
+                return currentSettings;
+            }
+            config.uri = canonicalUri;
+
+            if (currentSettings.activeConfigurationId === id) {
+                const activated = activateRemoteConfiguration(currentSettings, id);
+                switchedActive = activated !== false;
+                if (activated) {
+                    return activated;
+                }
+            }
+            return currentSettings;
+        }, true);
+
+        const updated = core.services.setting.currentSettings().remoteConfigurations?.[id];
+        if (!updated) {
+            process.stderr.write(`[Info] Remote configuration not found: ${id}\n`);
+            return false;
+        }
+
+        if (switchedActive) {
+            await core.services.control.applySettings();
+        }
+
+        console.error(`[Command] remote-set ${id}`);
+        return true;
+    }
+
+    if (options.command === "remote-activate") {
+        if (options.commandArgs.length < 1) {
+            throw new Error("remote-activate requires one argument: <remote-id>");
+        }
+        const id = options.commandArgs[0].trim();
+        if (!id) {
+            throw new Error("remote-activate requires a non-empty remote-id");
+        }
+
+        let switched = false;
+        await core.services.setting.updateSettings((currentSettings) => {
+            const activated = activateRemoteConfiguration(currentSettings, id);
+            if (activated) {
+                switched = true;
+                return activated;
+            }
+            return currentSettings;
+        }, true);
+
+        if (!switched) {
+            process.stderr.write(`[Info] Failed to activate remote configuration: ${id}\n`);
+            return false;
+        }
+
+        await core.services.control.applySettings();
+        console.error(`[Command] remote-activate ${id}`);
+        return true;
+    }
+
     throw new Error(`Unsupported command: ${options.command}`);
 }

src/apps/cli/commands/runCommand.unit.spec.ts

@@ -1,12 +1,19 @@
 import * as processSetting from "@lib/API/processSetting";
+import { ConnectionStringParser } from "@lib/common/ConnectionString";
 import { configURIBase } from "@lib/common/models/shared.const";
-import { DEFAULT_SETTINGS } from "@lib/common/types";
+import { DEFAULT_SETTINGS, REMOTE_COUCHDB, REMOTE_MINIO, REMOTE_P2P } from "@lib/common/types";
 import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
 import { runCommand } from "./runCommand";
 import type { CLIOptions } from "./types";
 import * as commandUtils from "./utils";
 
 function createCoreMock() {
+    const liveSettings = {
+        ...DEFAULT_SETTINGS,
+        remoteConfigurations: {},
+        activeConfigurationId: "",
+        P2P_ActiveRemoteConfigurationId: "",
+    } as any;
     return {
         services: {
             control: {
@@ -16,6 +23,10 @@ function createCoreMock() {
             setting: {
                 applyExternalSettings: vi.fn(async () => {}),
                 applyPartial: vi.fn(async () => {}),
+                currentSettings: vi.fn(() => liveSettings),
+                updateSettings: vi.fn(async (updater: any) => {
+                    updater(liveSettings);
+                }),
             },
         },
         serviceModules: {
@@ -56,6 +67,115 @@ async function createSetupURI(passphrase: string): Promise<string> {
     return await processSetting.encodeSettingsToSetupURI(settings, passphrase);
 }
 
+function captureStdout() {
+    const writes: string[] = [];
+    const spy = vi.spyOn(process.stdout, "write").mockImplementation((chunk: any) => {
+        writes.push(typeof chunk === "string" ? chunk : String(chunk));
+        return true;
+    });
+    return {
+        spy,
+        lines: () =>
+            writes
+                .join("")
+                .split("\n")
+                .map((e) => e.trim())
+                .filter((e) => e.length > 0),
+    };
+}
+
+function parseAddedRemoteIdFromLines(lines: string[]): string {
+    // remote-add prints: <id>\t<name>\t<redacted-connstr>
+    const last = lines.length > 0 ? lines[lines.length - 1] : "";
+    return last.split("\t")[0] || "";
+}
+
+type ProtocolFixture = {
+    protocol: string;
+    connectionString: string;
+    assertProjectedFields: (settings: any) => void;
+};
+
+const protocolFixtures: ProtocolFixture[] = [
+    {
+        protocol: "couchdb",
+        connectionString: ConnectionStringParser.serialize({
+            type: "couchdb",
+            settings: {
+                couchDB_URI: "https://db.example.com:5984",
+                couchDB_USER: "user1",
+                couchDB_PASSWORD: "pass1",
+                couchDB_DBNAME: "vault1",
+                couchDB_CustomHeaders: "",
+                useJWT: false,
+                jwtAlgorithm: "",
+                jwtKey: "",
+                jwtKid: "",
+                jwtSub: "",
+                jwtExpDuration: 5,
+                useRequestAPI: false,
+            },
+        }),
+        assertProjectedFields: (settings) => {
+            expect(settings.remoteType).toBe(REMOTE_COUCHDB);
+            expect(settings.couchDB_URI).toBe("https://db.example.com:5984");
+            expect(settings.couchDB_USER).toBe("user1");
+            expect(settings.couchDB_PASSWORD).toBe("pass1");
+            expect(settings.couchDB_DBNAME).toBe("vault1");
+        },
+    },
+    {
+        protocol: "s3",
+        connectionString: ConnectionStringParser.serialize({
+            type: "s3",
+            settings: {
+                accessKey: "ak",
+                secretKey: "sk",
+                endpoint: "https://s3.example.com",
+                bucket: "bucket-1",
+                region: "ap-northeast-1",
+                bucketPrefix: "vault/",
+                useCustomRequestHandler: true,
+                bucketCustomHeaders: "x-test:1",
+                forcePathStyle: false,
+            },
+        }),
+        assertProjectedFields: (settings) => {
+            expect(settings.remoteType).toBe(REMOTE_MINIO);
+            expect(settings.accessKey).toBe("ak");
+            expect(settings.secretKey).toBe("sk");
+            expect(settings.endpoint).toBe("https://s3.example.com");
+            expect(settings.bucket).toBe("bucket-1");
+            expect(settings.region).toBe("ap-northeast-1");
+        },
+    },
+    {
+        protocol: "p2p",
+        connectionString: ConnectionStringParser.serialize({
+            type: "p2p",
+            settings: {
+                P2P_Enabled: false,
+                P2P_roomID: "room-abc",
+                P2P_passphrase: "pass-123",
+                P2P_relays: "wss://relay.example",
+                P2P_AppID: "self-hosted-livesync",
+                P2P_AutoStart: true,
+                P2P_AutoBroadcast: false,
+                P2P_turnServers: "turn:turn.example:3478",
+                P2P_turnUsername: "turn-user",
+                P2P_turnCredential: "turn-pass",
+            },
+        }),
+        assertProjectedFields: (settings) => {
+            expect(settings.remoteType).toBe(REMOTE_P2P);
+            expect(settings.P2P_roomID).toBe("room-abc");
+            expect(settings.P2P_passphrase).toBe("pass-123");
+            expect(settings.P2P_relays).toBe("wss://relay.example");
+            expect(settings.P2P_AppID).toBe("self-hosted-livesync");
+        },
+    },
+];
+
 describe("runCommand abnormal cases", () => {
     const context = {
         databasePath: "/tmp/vault",
@@ -202,4 +322,254 @@ describe("runCommand abnormal cases", () => {
         expect(core.services.setting.applyExternalSettings).not.toHaveBeenCalled();
         expect(core.services.control.applySettings).not.toHaveBeenCalled();
     });
+
+    it("remote-add stores canonical URI and prints the created id", async () => {
+        const core = createCoreMock();
+        const stdout = vi.spyOn(process.stdout, "write").mockImplementation(() => true);
+
+        const result = await runCommand(makeOptions("remote-add", ["my-remote", "sls+https://example.com/db"]), {
+            ...context,
+            core,
+        });
+
+        expect(result).toBe(true);
+        const settings = core.services.setting.currentSettings();
+        const ids = Object.keys(settings.remoteConfigurations);
+        expect(ids.length).toBe(1);
+        expect(settings.remoteConfigurations[ids[0]].name).toBe("my-remote");
+        expect(settings.remoteConfigurations[ids[0]].uri).toContain("sls+https://example.com/db");
+        expect(settings.activeConfigurationId).toBe(ids[0]);
+        expect(stdout).toHaveBeenCalled();
+    });
+
+    it("remote-activate switches active remote and applies settings", async () => {
+        const core = createCoreMock();
+        const settings = core.services.setting.currentSettings();
+        settings.remoteConfigurations.r1 = {
+            id: "r1",
+            name: "R1",
+            uri: "sls+https://example.com/db1",
+            isEncrypted: false,
+        };
+        settings.remoteConfigurations.r2 = {
+            id: "r2",
+            name: "R2",
+            uri: "sls+https://example.com/db2",
+            isEncrypted: false,
+        };
+        settings.activeConfigurationId = "r1";
+
+        const result = await runCommand(makeOptions("remote-activate", ["r2"]), {
+            ...context,
+            core,
+        });
+
+        expect(result).toBe(true);
+        expect(settings.activeConfigurationId).toBe("r2");
+        expect(core.services.control.applySettings).toHaveBeenCalledTimes(1);
+    });
+
+    it("remote-rm removes active remote and promotes first remaining", async () => {
+        const core = createCoreMock();
+        const settings = core.services.setting.currentSettings();
+        settings.remoteConfigurations.r1 = {
+            id: "r1",
+            name: "R1",
+            uri: "sls+https://example.com/db1",
+            isEncrypted: false,
+        };
+        settings.remoteConfigurations.r2 = {
+            id: "r2",
+            name: "R2",
+            uri: "sls+https://example.com/db2",
+            isEncrypted: false,
+        };
+        settings.activeConfigurationId = "r1";
+
+        const result = await runCommand(makeOptions("remote-rm", ["r1"]), {
+            ...context,
+            core,
+        });
+
+        expect(result).toBe(true);
+        expect(settings.remoteConfigurations.r1).toBeUndefined();
+        expect(settings.activeConfigurationId).toBe("r2");
+        expect(core.services.control.applySettings).toHaveBeenCalledTimes(1);
+    });
+
+    it("remote-export prints the exact stored connection string", async () => {
+        const core = createCoreMock();
+        const settings = core.services.setting.currentSettings();
+        settings.remoteConfigurations.r1 = {
+            id: "r1",
+            name: "R1",
+            uri: "sls+https://example.com/db?db=vault",
+            isEncrypted: false,
+        };
+        const stdout = captureStdout();
+
+        const result = await runCommand(makeOptions("remote-export", ["r1"]), {
+            ...context,
+            core,
+        });
+
+        expect(result).toBe(true);
+        const outLines = stdout.lines();
+        expect(outLines.length > 0 ? outLines[outLines.length - 1] : "").toBe("sls+https://example.com/db?db=vault");
+        expect(stdout.spy).toHaveBeenCalled();
+    });
+
+    it("remote-set updates URI and applies settings when target is active", async () => {
+        const core = createCoreMock();
+        const settings = core.services.setting.currentSettings();
+        settings.remoteConfigurations.r1 = {
+            id: "r1",
+            name: "R1",
+            uri: "sls+https://old.example/db",
+            isEncrypted: false,
+        };
+        settings.activeConfigurationId = "r1";
+
+        const result = await runCommand(makeOptions("remote-set", ["r1", "sls+https://new.example/db"]), {
+            ...context,
+            core,
+        });
+
+        expect(result).toBe(true);
+        expect(settings.remoteConfigurations.r1.uri).toContain("sls+https://new.example/db");
+        expect(core.services.control.applySettings).toHaveBeenCalledTimes(1);
+    });
+
+    it.each(protocolFixtures)(
+        "remote-activate projects effective settings for $protocol",
+        async ({ connectionString, assertProjectedFields }) => {
+            const core = createCoreMock();
+            const settings = core.services.setting.currentSettings();
+            settings.remoteConfigurations.r1 = {
+                id: "r1",
+                name: "R1",
+                uri: "sls+https://old.example/?db=old",
+                isEncrypted: false,
+            };
+            settings.remoteConfigurations.r2 = {
+                id: "r2",
+                name: "R2",
+                uri: connectionString,
+                isEncrypted: false,
+            };
+            settings.activeConfigurationId = "r1";
+
+            const result = await runCommand(makeOptions("remote-activate", ["r2"]), {
+                ...context,
+                core,
+            });
+
+            expect(result).toBe(true);
+            expect(settings.activeConfigurationId).toBe("r2");
+            assertProjectedFields(settings);
+        }
+    );
+
+    it.each(protocolFixtures)(
+        "remote-set projects effective settings for active remote ($protocol)",
+        async ({ connectionString, assertProjectedFields }) => {
+            const core = createCoreMock();
+            const settings = core.services.setting.currentSettings();
+            settings.remoteConfigurations.r1 = {
+                id: "r1",
+                name: "R1",
+                uri: "sls+https://old.example/?db=old",
+                isEncrypted: false,
+            };
+            settings.activeConfigurationId = "r1";
+
+            const result = await runCommand(makeOptions("remote-set", ["r1", connectionString]), {
+                ...context,
+                core,
+            });
+
+            expect(result).toBe(true);
+            assertProjectedFields(settings);
+        }
+    );
+
+    it.each(protocolFixtures)(
+        "remote-rm projects promoted active remote effective settings for $protocol",
+        async ({ connectionString, assertProjectedFields }) => {
+            const core = createCoreMock();
+            const settings = core.services.setting.currentSettings();
+            settings.remoteConfigurations.r1 = {
+                id: "r1",
+                name: "R1",
+                uri: "sls+https://old.example/?db=old",
+                isEncrypted: false,
+            };
+            settings.remoteConfigurations.r2 = {
+                id: "r2",
+                name: "R2",
+                uri: connectionString,
+                isEncrypted: false,
+            };
+            settings.activeConfigurationId = "r1";
+
+            const result = await runCommand(makeOptions("remote-rm", ["r1"]), {
+                ...context,
+                core,
+            });
+
+            expect(result).toBe(true);
+            expect(settings.activeConfigurationId).toBe("r2");
+            assertProjectedFields(settings);
+        }
+    );
+
+    it.each([
+        ["couchdb", "sls+https://user:pass@example.com:5984/?db=vault"] as const,
+        [
+            "s3",
+            "sls+s3://ak:sk@example.com/?endpoint=https%3A%2F%2Fs3.example.com&bucket=my-bucket&region=ap-northeast-1",
+        ] as const,
+        [
+            "p2p",
+            "sls+p2p://room-abc?passphrase=pass-123&relays=wss%3A%2F%2Frelay.example&appId=self-hosted-livesync",
+        ] as const,
+    ])("remote command round-trip works for %s", async (_protocol, initialConnStr) => {
+        const core = createCoreMock();
+
+        const addOut = captureStdout();
+        const addResult = await runCommand(makeOptions("remote-add", ["rt", initialConnStr]), {
+            ...context,
+            core,
+        });
+        expect(addResult).toBe(true);
+        const remoteId = parseAddedRemoteIdFromLines(addOut.lines());
+        expect(remoteId).not.toBe("");
+
+        const export1Out = captureStdout();
+        const export1Result = await runCommand(makeOptions("remote-export", [remoteId]), {
+            ...context,
+            core,
+        });
+        expect(export1Result).toBe(true);
+        const export1Lines = export1Out.lines();
+        const exported1 = export1Lines.length > 0 ? export1Lines[export1Lines.length - 1] : "";
+        expect(exported1).toBe(ConnectionStringParser.serialize(ConnectionStringParser.parse(initialConnStr)));
+
+        const roundTripInput = ConnectionStringParser.serialize(ConnectionStringParser.parse(exported1));
+        const setResult = await runCommand(makeOptions("remote-set", [remoteId, roundTripInput]), {
+            ...context,
+            core,
+        });
+        expect(setResult).toBe(true);
+
+        const export2Out = captureStdout();
+        const export2Result = await runCommand(makeOptions("remote-export", [remoteId]), {
+            ...context,
+            core,
+        });
+        expect(export2Result).toBe(true);
+        const export2Lines = export2Out.lines();
+        const exported2 = export2Lines.length > 0 ? export2Lines[export2Lines.length - 1] : "";
+        expect(exported2).toBe(roundTripInput);
+    });
 });

src/apps/cli/commands/types.ts

@@ -1,5 +1,6 @@
 import { LiveSyncBaseCore } from "../../../LiveSyncBaseCore";
 import { ServiceContext } from "@lib/services/base/ServiceBase";
+import type { ObsidianLiveSyncSettings } from "@lib/common/types";
 
 export type CLICommand =
     | "daemon"
@@ -19,6 +20,12 @@ export type CLICommand =
     | "rm"
     | "resolve"
     | "mirror"
+    | "remote-add"
+    | "remote-rm"
+    | "remote-ls"
+    | "remote-export"
+    | "remote-set"
+    | "remote-activate"
     | "init-settings";
 
 export interface CLIOptions {
@@ -29,15 +36,27 @@ export interface CLIOptions {
     force?: boolean;
     command: CLICommand;
     commandArgs: string[];
+    interval?: number;
 }
 
 export interface CLICommandContext {
     databasePath: string;
     core: LiveSyncBaseCore<ServiceContext, any>;
     settingsPath: string;
+    originalSyncSettings: Pick<
+        ObsidianLiveSyncSettings,
+        | "liveSync"
+        | "syncOnStart"
+        | "periodicReplication"
+        | "syncOnSave"
+        | "syncOnEditorSave"
+        | "syncOnFileOpen"
+        | "syncAfterMerge"
+    >;
 }
 
 export const VALID_COMMANDS = new Set([
+    "daemon",
     "sync",
     "p2p-peers",
     "p2p-sync",
@@ -54,5 +73,11 @@ export const VALID_COMMANDS = new Set([
     "rm",
     "resolve",
     "mirror",
+    "remote-add",
+    "remote-rm",
+    "remote-ls",
+    "remote-export",
+    "remote-set",
+    "remote-activate",
     "init-settings",
 ] as const);

src/apps/cli/deploy/install.sh

@@ -0,0 +1,187 @@
+#!/usr/bin/env bash
+# install.sh — install livesync-cli as a systemd service
+#
+# Usage:
+#   install.sh [--user] [--system] [--vault <path>] [--interval <N>]
+#
+# Defaults: user install, prompts for vault path if not supplied.
+set -euo pipefail
+
+SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd -- "$SCRIPT_DIR/../../.." && pwd)"
+CLI_DIR="$REPO_ROOT/src/apps/cli"
+SERVICE_TEMPLATE="$SCRIPT_DIR/livesync-cli.service"
+
+# ── Argument parsing ────────────────────────────────────────────────────────
+INSTALL_MODE="user"
+VAULT_PATH=""
+INTERVAL=""
+FORCE=0
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --user)
+            INSTALL_MODE="user"
+            shift
+            ;;
+        --system)
+            INSTALL_MODE="system"
+            shift
+            ;;
+        --vault)
+            if [[ -z "${2:-}" ]]; then
+                echo "Error: --vault requires a path argument" >&2
+                exit 1
+            fi
+            VAULT_PATH="$2"
+            shift 2
+            ;;
+        --interval)
+            if [[ -z "${2:-}" ]]; then
+                echo "Error: --interval requires a numeric argument" >&2
+                exit 1
+            fi
+            INTERVAL="$2"
+            if ! [[ "$INTERVAL" =~ ^[1-9][0-9]*$ ]]; then
+                echo "Error: --interval requires a positive integer, got '$INTERVAL'" >&2
+                exit 1
+            fi
+            shift 2
+            ;;
+        --force|-f)
+            FORCE=1
+            shift
+            ;;
+        --help|-h)
+            cat <<EOF
+Usage: install.sh [--user|--system] [--vault <path>] [--interval <N>] [--force]
+
+  --user       Install as a user systemd service (default, ~/.config/systemd/user/)
+  --system     Install as a system systemd service (/etc/systemd/system/)
+  --vault      Path to the vault directory (prompted if omitted)
+  --interval   Poll CouchDB every N seconds instead of using the _changes feed
+  --force      Overwrite existing service unit without prompting
+EOF
+            exit 0
+            ;;
+        *)
+            echo "Error: Unknown argument: $1" >&2
+            exit 1
+            ;;
+    esac
+done
+
+# ── Vault path ──────────────────────────────────────────────────────────────
+if [[ -z "$VAULT_PATH" ]]; then
+    if [ ! -t 0 ]; then
+        echo "Error: --vault is required in non-interactive mode" >&2
+        exit 1
+    fi
+    printf 'Vault path: '
+    read -r VAULT_PATH
+fi
+
+_orig_vault="$VAULT_PATH"
+if ! VAULT_PATH="$(cd -- "$VAULT_PATH" 2>/dev/null && pwd)"; then
+    echo "Error: vault directory does not exist: $_orig_vault" >&2
+    exit 1
+fi
+
+echo "[INFO] Vault: $VAULT_PATH"
+echo "[INFO] Install mode: $INSTALL_MODE"
+
+# ── Build ────────────────────────────────────────────────────────────────────
+echo "[INFO] Building CLI from $REPO_ROOT..."
+(cd "$REPO_ROOT" && npm install --silent)
+(cd "$CLI_DIR" && npm run build)
+
+BUILT_CJS="$CLI_DIR/dist/index.cjs"
+if [[ ! -f "$BUILT_CJS" ]]; then
+    echo "Error: build output not found: $BUILT_CJS" >&2
+    exit 1
+fi
+
+# ── Install binary ───────────────────────────────────────────────────────────
+if [[ "$INSTALL_MODE" == "user" ]]; then
+    BIN_DIR="$HOME/.local/bin"
+    UNIT_DIR="$HOME/.config/systemd/user"
+    SYSTEMCTL_FLAGS="--user"
+else
+    BIN_DIR="/usr/local/bin"
+    UNIT_DIR="/etc/systemd/system"
+    SYSTEMCTL_FLAGS=""
+fi
+
+mkdir -p "$BIN_DIR"
+
+LIVESYNC_BIN="$BIN_DIR/livesync-cli"
+LIVESYNC_JS="$BIN_DIR/livesync-cli.js"
+
+# Copy the CJS bundle so the wrapper is self-contained and independent of the
+# build directory location.
+cp "$BUILT_CJS" "$LIVESYNC_JS"
+
+# Write a bash wrapper that invokes node on the installed bundle.
+cat > "$LIVESYNC_BIN" <<WRAPPER
+#!/usr/bin/env bash
+exec node "$LIVESYNC_JS" "\$@"
+WRAPPER
+chmod +x "$LIVESYNC_BIN"
+echo "[INFO] Installed bundle:  $LIVESYNC_JS"
+echo "[INFO] Installed binary: $LIVESYNC_BIN"
+
+# ── Write systemd unit ───────────────────────────────────────────────────────
+mkdir -p "$UNIT_DIR"
+UNIT_PATH="$UNIT_DIR/livesync-cli.service"
+
+EXEC_START="\"$LIVESYNC_BIN\" \"$VAULT_PATH\""
+if [[ -n "$INTERVAL" ]]; then
+    EXEC_START="\"$LIVESYNC_BIN\" \"$VAULT_PATH\" --interval $INTERVAL"
+fi
+
+# Check for existing service and offer to overwrite.
+if [[ -f "$UNIT_PATH" ]] && [[ "$FORCE" -eq 0 ]]; then
+    if [ ! -t 0 ]; then
+        echo "Error: service unit already exists at $UNIT_PATH; use --force to overwrite" >&2
+        exit 1
+    fi
+    printf 'Service unit already exists at %s. Overwrite? [y/N]: ' "$UNIT_PATH"
+    read -r CONFIRM
+    case "$CONFIRM" in
+        [yY]|[yY][eE][sS]) : ;;
+        *)
+            echo "[INFO] Aborted. Existing unit left in place."
+            exit 0
+            ;;
+    esac
+fi
+
+# In awk gsub(), '&' in the replacement means "matched text"; escape any literal '&'
+# in path variables before passing them as awk replacement strings.
+AWK_BIN="${LIVESYNC_BIN//&/\\&}"
+AWK_VAULT="${VAULT_PATH//&/\\&}"
+awk -v bin="$AWK_BIN" -v vault="$AWK_VAULT" -v exec_start="ExecStart=$EXEC_START" \
+    '/^ExecStart=/ { print exec_start; next } {gsub("LIVESYNC_BIN", bin); gsub("LIVESYNC_VAULT_PATH", vault); print}' \
+    "$SERVICE_TEMPLATE" > "$UNIT_PATH"
+
+echo "[INFO] Installed unit: $UNIT_PATH"
+
+# ── Enable service ───────────────────────────────────────────────────────────
+if ! command -v systemctl >/dev/null 2>&1; then
+    echo "[WARN] systemctl not found — skipping service activation"
+    echo "[INFO] To enable manually, copy $UNIT_PATH to the correct systemd directory and run:"
+    echo "         systemctl $SYSTEMCTL_FLAGS daemon-reload"
+    echo "         systemctl $SYSTEMCTL_FLAGS enable --now livesync-cli"
+    exit 0
+fi
+
+# shellcheck disable=SC2086
+systemctl $SYSTEMCTL_FLAGS daemon-reload
+# shellcheck disable=SC2086
+systemctl $SYSTEMCTL_FLAGS enable --now livesync-cli
+
+echo ""
+echo "[Done] livesync-cli service installed and started."
+echo ""
+# shellcheck disable=SC2086
+systemctl $SYSTEMCTL_FLAGS status livesync-cli --no-pager || true

src/apps/cli/deploy/livesync-cli.service

@@ -0,0 +1,17 @@
+[Unit]
+Description=Self-hosted LiveSync CLI Daemon
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=LIVESYNC_BIN LIVESYNC_VAULT_PATH
+Restart=on-failure
+RestartSec=10
+TimeoutStartSec=300
+StandardOutput=journal
+StandardError=journal
+LimitNOFILE=65536
+
+[Install]
+WantedBy=default.target

src/apps/cli/main.ts

@@ -8,7 +8,6 @@ import * as path from "path";
 import { NodeServiceContext, NodeServiceHub } from "./services/NodeServiceHub";
 import { configureNodeLocalStorage, ensureGlobalNodeLocalStorage } from "./services/NodeLocalStorage";
 import { LiveSyncBaseCore } from "../../LiveSyncBaseCore";
-import { ModuleReplicatorP2P } from "../../modules/core/ModuleReplicatorP2P";
 import { initialiseServiceModulesCLI } from "./serviceModules/CLIServiceModules";
 import { DEFAULT_SETTINGS, LOG_LEVEL_VERBOSE, type LOG_LEVEL, type ObsidianLiveSyncSettings } from "@lib/common/types";
 import type { InjectableServiceHub } from "@lib/services/implements/injectable/InjectableServiceHub";
@@ -26,6 +25,8 @@ import { VALID_COMMANDS } from "./commands/types";
 import type { CLICommand, CLIOptions } from "./commands/types";
 import { getPathFromUXFileInfo } from "@lib/common/typeUtils";
 import { stripAllPrefixes } from "@lib/string_and_binary/path";
+import { IgnoreRules } from "./serviceModules/IgnoreRules";
+import { useP2PReplicatorFeature } from "@/lib/src/replication/trystero/useP2PReplicatorFeature";
 
 const SETTINGS_FILE = ".livesync/settings.json";
 ensureGlobalNodeLocalStorage();
@@ -43,7 +44,8 @@ Arguments:
   database-path           Path to the local database directory
 
 Commands:
-  sync                    Run one replication cycle and exit
+    daemon                  (default) Run mirror scan then continuously sync CouchDB <-> local filesystem
+    sync                    Run one replication cycle and exit
     p2p-peers <timeout>     Show discovered peers as [peer]\t<peer-id>\t<peer-name>
     p2p-sync <peer> <timeout>
                             Sync with the specified peer-id or peer-name
@@ -60,24 +62,46 @@ Commands:
     rm <path>               Mark a file as deleted in local database
     resolve <path> <rev>    Resolve conflicts by keeping <rev> and deleting others
     mirror [vault-path]     Mirror database contents to the local file system (vault-path defaults to database-path)
+    remote-add <name> <connstr>
+                            Add a remote configuration from a connection string
+    remote-rm <remote-id>    Remove a remote configuration by ID
+    remote-ls                List stored remote configurations
+    remote-export <remote-id>
+                            Export a remote connection string by ID
+    remote-set <remote-id> <connstr>
+                            Replace a stored remote connection string by ID
+    remote-activate <remote-id>
+                            Activate a stored remote configuration by ID
+
+Options:
+  --interval <N>, -i <N>  (daemon only) Poll CouchDB every N seconds instead of using the _changes feed
+
 Examples:
-  livesync-cli ./my-database sync
-  livesync-cli ./my-database p2p-peers 5
-  livesync-cli ./my-database p2p-sync my-peer-name 15
-  livesync-cli ./my-database p2p-host
-  livesync-cli ./my-database --settings ./custom-settings.json push ./note.md folder/note.md
-  livesync-cli ./my-database pull folder/note.md ./exports/note.md
-  livesync-cli ./my-database pull-rev folder/note.md ./exports/note.old.md 3-abcdef
-  livesync-cli ./my-database setup "obsidian://setuplivesync?settings=..."
-  echo "Hello" | livesync-cli ./my-database put notes/hello.md
-  livesync-cli ./my-database cat notes/hello.md
-  livesync-cli ./my-database cat-rev notes/hello.md 3-abcdef
-  livesync-cli ./my-database ls notes/
-  livesync-cli ./my-database info notes/hello.md
-  livesync-cli ./my-database rm notes/hello.md
-  livesync-cli ./my-database resolve notes/hello.md 3-abcdef
-  livesync-cli init-settings ./data.json
-  livesync-cli ./my-database --verbose
+    livesync-cli ./my-database                        Run daemon (LiveSync mode)
+    livesync-cli ./my-database --interval 30          Run daemon (polling every 30s)
+    livesync-cli ./my-database sync
+    livesync-cli ./my-database p2p-peers 5
+    livesync-cli ./my-database p2p-sync my-peer-name 15
+    livesync-cli ./my-database p2p-host
+    livesync-cli ./my-database --settings ./custom-settings.json push ./note.md folder/note.md
+    livesync-cli ./my-database pull folder/note.md ./exports/note.md
+    livesync-cli ./my-database pull-rev folder/note.md ./exports/note.old.md 3-abcdef
+    livesync-cli ./my-database setup "obsidian://setuplivesync?settings=..."
+    echo "Hello" | livesync-cli ./my-database put notes/hello.md
+    livesync-cli ./my-database cat notes/hello.md
+    livesync-cli ./my-database cat-rev notes/hello.md 3-abcdef
+    livesync-cli ./my-database ls notes/
+    livesync-cli ./my-database info notes/hello.md
+    livesync-cli ./my-database rm notes/hello.md
+    livesync-cli ./my-database resolve notes/hello.md 3-abcdef
+    livesync-cli ./my-database remote-add my-remote "sls+https://user:pass@example.com/db"
+    livesync-cli ./my-database remote-ls
+    livesync-cli ./my-database remote-export remote-abc123
+    livesync-cli ./my-database remote-set remote-abc123 "sls+s3://ak:sk@example.com/?endpoint=https%3A%2F%2Fs3.example.com&bucket=mybucket"
+    livesync-cli ./my-database remote-activate remote-abc123
+    livesync-cli ./my-database remote-rm remote-abc123
+    livesync-cli init-settings ./data.json
+    livesync-cli ./my-database --verbose
         `);
 }
 
@@ -94,6 +118,7 @@ export function parseArgs(): CLIOptions {
     let verbose = false;
     let debug = false;
     let force = false;
+    let interval: number | undefined;
     let command: CLICommand = "daemon";
     const commandArgs: string[] = [];
 
@@ -110,6 +135,21 @@ export function parseArgs(): CLIOptions {
                 settingsPath = args[i];
                 break;
             }
+            case "--interval":
+            case "-i": {
+                i++;
+                if (!args[i]) {
+                    console.error(`Error: Missing value for ${token}`);
+                    process.exit(1);
+                }
+                const n = parseInt(args[i], 10);
+                if (!Number.isInteger(n) || n <= 0) {
+                    console.error(`Error: --interval requires a positive integer, got '${args[i]}'`);
+                    process.exit(1);
+                }
+                interval = n;
+                break;
+            }
             case "--debug":
             case "-d":
                 // debugging automatically enables verbose logging, as it is intended for debugging issues.
@@ -164,6 +204,7 @@ export function parseArgs(): CLIOptions {
         force,
         command,
         commandArgs,
+        interval,
     };
 }
 
@@ -197,10 +238,16 @@ async function createDefaultSettingsFile(options: CLIOptions) {
 
 export async function main() {
     const options = parseArgs();
+    if (options.interval && options.command !== "daemon") {
+        console.error(`Warning: --interval is only used in daemon mode, ignored for '${options.command}'`);
+    }
     const avoidStdoutNoise =
         options.command === "cat" ||
         options.command === "cat-rev" ||
         options.command === "ls" ||
+        options.command === "remote-add" ||
+        options.command === "remote-ls" ||
+        options.command === "remote-export" ||
         options.command === "p2p-peers" ||
         options.command === "info" ||
         options.command === "rm" ||
@@ -248,6 +295,17 @@ export async function main() {
     infoLog(`Settings: ${settingsPath}`);
     infoLog("");
 
+    // For daemon and mirror mode, load ignore rules before the core is constructed so that
+    // chokidar's ignored option is populated when beginWatch() fires during onLoad().
+    const watchEnabled = options.command === "daemon";
+    const vaultPath =
+        options.command === "mirror" && options.commandArgs[0] ? path.resolve(options.commandArgs[0]) : databasePath;
+    let ignoreRules: IgnoreRules | undefined;
+    if (options.command === "daemon" || options.command === "mirror") {
+        ignoreRules = new IgnoreRules(vaultPath);
+        await ignoreRules.load();
+    }
+
     // Create service context and hub
     const context = new NodeServiceContext(databasePath);
     const serviceHubInstance = new NodeServiceHub<NodeServiceContext>(databasePath, context);
@@ -278,11 +336,14 @@ export async function main() {
         }
         console.error(`${prefix} ${message}`);
     });
-    // Prevent replication result to be processed automatically.
-    serviceHubInstance.replication.processSynchroniseResult.addHandler(async () => {
-        console.error(`[Info] Replication result received, but not processed automatically in CLI mode.`);
-        return await Promise.resolve(true);
-    }, -100);
+    // Prevent replication result from being processed automatically in non-daemon commands.
+    // In daemon mode the default handler must run so changes are applied to the filesystem.
+    if (options.command !== "daemon") {
+        serviceHubInstance.replication.processSynchroniseResult.addHandler(async () => {
+            console.error(`[Info] Replication result received, but not processed automatically in CLI mode.`);
+            return await Promise.resolve(true);
+        }, -100);
+    }
 
     // Setup settings handlers
     const settingService = serviceHubInstance.setting;
@@ -324,18 +385,13 @@ export async function main() {
     const core = new LiveSyncBaseCore(
         serviceHubInstance,
         (core: LiveSyncBaseCore<NodeServiceContext, any>, serviceHub: InjectableServiceHub<NodeServiceContext>) => {
-            const mirrorVaultPath =
-                options.command === "mirror" && options.commandArgs[0]
-                    ? path.resolve(options.commandArgs[0])
-                    : databasePath;
-            return initialiseServiceModulesCLI(mirrorVaultPath, core, serviceHub);
+            return initialiseServiceModulesCLI(vaultPath, core, serviceHub, ignoreRules, watchEnabled);
         },
-        (core) => [
-            // No modules need to be registered for P2P replication in CLI. Directly using Replicators in p2p.ts
-            // new ModuleReplicatorP2P(core),
-        ],
+        (core) => [],
         () => [], // No add-ons
         (core) => {
+            // Register P2P replicator feature.
+            const _replicator = useP2PReplicatorFeature(core);
             // Add target filter to prevent internal files are handled
             core.services.vault.isTargetFile.addHandler(async (target) => {
                 const targetPath = stripAllPrefixes(getPathFromUXFileInfo(target));
@@ -344,8 +400,25 @@ export async function main() {
                 if (parts.some((part) => part.startsWith("."))) {
                     return await Promise.resolve(false);
                 }
+                // PouchDB LevelDB database directory lives in the vault directory.
+                if (parts[0]?.endsWith("-livesync-v2")) {
+                    return await Promise.resolve(false);
+                }
                 return await Promise.resolve(true);
             }, -1 /* highest priority */);
+
+            // Apply user-defined ignore rules for daemon mode (lower priority, runs after dotfile check).
+            if (ignoreRules) {
+                const rules = ignoreRules;
+                core.services.vault.isTargetFile.addHandler(async (target) => {
+                    const targetPath = stripAllPrefixes(getPathFromUXFileInfo(target));
+                    if (rules.shouldIgnore(targetPath)) {
+                        return false;
+                    }
+                    // undefined = pass through to next handler in chain
+                    return undefined;
+                }, 0);
+            }
         }
     );
 
@@ -366,6 +439,25 @@ export async function main() {
     process.on("SIGINT", () => shutdown("SIGINT"));
     process.on("SIGTERM", () => shutdown("SIGTERM"));
 
+    // Save the settings file before any lifecycle events can mutate and persist them.
+    // suspendAllSync and other lifecycle hooks clobber sync settings in memory, and
+    // various code paths persist the clobbered state to disk. We restore on shutdown.
+    const settingsBackup = await fs.readFile(settingsPath, "utf-8").catch(() => null!);
+
+    // Restore settings file on any exit to undo lifecycle mutations.
+    // Write to a temp path first so a crash mid-write doesn't leave a truncated file.
+    process.on("exit", () => {
+        if (settingsBackup) {
+            const tmpPath = settingsPath + ".tmp";
+            try {
+                require("fs").writeFileSync(tmpPath, settingsBackup, "utf-8");
+                require("fs").renameSync(tmpPath, settingsPath);
+            } catch (err) {
+                console.error("[Settings] Failed to restore settings on exit:", err);
+            }
+        }
+    });
+
     // Start the core
     try {
         infoLog(`[Starting] Initializing LiveSync...`);
@@ -375,6 +467,18 @@ export async function main() {
             console.error(`[Error] Failed to initialize LiveSync`);
             process.exit(1);
         }
+        // Capture sync settings before suspendAllSync() clobbers them.
+        // Used by daemon mode to restore the correct sync behaviour after the mirror scan.
+        const settingsBeforeSuspend = core.services.setting.currentSettings();
+        const originalSyncSettings = {
+            liveSync: settingsBeforeSuspend.liveSync,
+            syncOnStart: settingsBeforeSuspend.syncOnStart,
+            periodicReplication: settingsBeforeSuspend.periodicReplication,
+            syncOnSave: settingsBeforeSuspend.syncOnSave,
+            syncOnEditorSave: settingsBeforeSuspend.syncOnEditorSave,
+            syncOnFileOpen: settingsBeforeSuspend.syncOnFileOpen,
+            syncAfterMerge: settingsBeforeSuspend.syncAfterMerge,
+        };
         await core.services.setting.suspendAllSync();
         await core.services.control.onReady();
 
@@ -400,7 +504,7 @@ export async function main() {
             infoLog("");
         }
 
-        const result = await runCommand(options, { databasePath, core, settingsPath });
+        const result = await runCommand(options, { databasePath, core, settingsPath, originalSyncSettings });
         if (!result) {
             console.error(`[Error] Command '${options.command}' failed`);
             process.exitCode = 1;
@@ -408,7 +512,7 @@ export async function main() {
             infoLog(`[Done] Command '${options.command}' completed`);
         }
 
-        if (options.command === "daemon") {
+        if (options.command === "daemon" && result) {
             // Keep the process running
             await new Promise(() => {});
         } else {

src/apps/cli/main.unit.spec.ts

@@ -85,4 +85,117 @@ describe("CLI parseArgs", () => {
         expect(parsed.command).toBe("p2p-host");
         expect(parsed.commandArgs).toEqual([]);
     });
+
+    it("parses remote-add command", () => {
+        process.argv = [
+            "node",
+            "livesync-cli",
+            "./databasePath",
+            "remote-add",
+            "my-remote",
+            "sls+https://user:pass@example.com/db",
+        ];
+        const parsed = parseArgs();
+
+        expect(parsed.databasePath).toBe("./databasePath");
+        expect(parsed.command).toBe("remote-add");
+        expect(parsed.commandArgs).toEqual(["my-remote", "sls+https://user:pass@example.com/db"]);
+    });
+
+    it("parses remote-activate command", () => {
+        process.argv = ["node", "livesync-cli", "./databasePath", "remote-activate", "remote-abc"];
+        const parsed = parseArgs();
+
+        expect(parsed.databasePath).toBe("./databasePath");
+        expect(parsed.command).toBe("remote-activate");
+        expect(parsed.commandArgs).toEqual(["remote-abc"]);
+    });
+
+    it("parses remote-export command", () => {
+        process.argv = ["node", "livesync-cli", "./databasePath", "remote-export", "remote-abc"];
+        const parsed = parseArgs();
+
+        expect(parsed.databasePath).toBe("./databasePath");
+        expect(parsed.command).toBe("remote-export");
+        expect(parsed.commandArgs).toEqual(["remote-abc"]);
+    });
+
+    it("parses remote-set command", () => {
+        process.argv = [
+            "node",
+            "livesync-cli",
+            "./databasePath",
+            "remote-set",
+            "remote-abc",
+            "sls+p2p://room-1?passphrase=abc",
+        ];
+        const parsed = parseArgs();
+
+        expect(parsed.databasePath).toBe("./databasePath");
+        expect(parsed.command).toBe("remote-set");
+        expect(parsed.commandArgs).toEqual(["remote-abc", "sls+p2p://room-1?passphrase=abc"]);
+    });
+
+    it("parses --interval flag with valid integer", () => {
+        process.argv = ["node", "livesync-cli", "./vault", "--interval", "30"];
+        const parsed = parseArgs();
+        expect(parsed.command).toBe("daemon");
+        expect(parsed.interval).toBe(30);
+    });
+
+    it("parses -i shorthand for --interval", () => {
+        process.argv = ["node", "livesync-cli", "./vault", "-i", "10"];
+        const parsed = parseArgs();
+        expect(parsed.interval).toBe(10);
+    });
+
+    it("exits 1 when --interval has no value", () => {
+        process.argv = ["node", "livesync-cli", "./vault", "--interval"];
+        const exitMock = mockProcessExit();
+        vi.spyOn(console, "error").mockImplementation(() => {});
+        expect(() => parseArgs()).toThrowError("__EXIT__:1");
+        expect(exitMock).toHaveBeenCalledWith(1);
+    });
+
+    it("exits 1 when --interval is not a positive integer", () => {
+        process.argv = ["node", "livesync-cli", "./vault", "--interval", "0"];
+        const exitMock = mockProcessExit();
+        vi.spyOn(console, "error").mockImplementation(() => {});
+        expect(() => parseArgs()).toThrowError("__EXIT__:1");
+        expect(exitMock).toHaveBeenCalledWith(1);
+    });
+
+    it("exits 1 when --interval is negative", () => {
+        process.argv = ["node", "livesync-cli", "./vault", "--interval", "-5"];
+        const exitMock = mockProcessExit();
+        vi.spyOn(console, "error").mockImplementation(() => {});
+        expect(() => parseArgs()).toThrowError("__EXIT__:1");
+    });
+
+    it("exits 1 when --interval is not numeric", () => {
+        process.argv = ["node", "livesync-cli", "./vault", "--interval", "abc"];
+        const exitMock = mockProcessExit();
+        vi.spyOn(console, "error").mockImplementation(() => {});
+        expect(() => parseArgs()).toThrowError("__EXIT__:1");
+    });
+
+    it("parses explicit daemon command", () => {
+        process.argv = ["node", "livesync-cli", "./vault", "daemon"];
+        const parsed = parseArgs();
+        expect(parsed.command).toBe("daemon");
+        expect(parsed.databasePath).toBe("./vault");
+    });
+
+    it("defaults to daemon when no command specified", () => {
+        process.argv = ["node", "livesync-cli", "./vault"];
+        const parsed = parseArgs();
+        expect(parsed.command).toBe("daemon");
+    });
+
+    it("parses explicit daemon command with --interval", () => {
+        process.argv = ["node", "livesync-cli", "./vault", "daemon", "--interval", "30"];
+        const parsed = parseArgs();
+        expect(parsed.command).toBe("daemon");
+        expect(parsed.interval).toBe(30);
+    });
 });

src/apps/cli/managers/CLIStorageEventManagerAdapter.ts

@@ -11,8 +11,11 @@ import type {
 } from "@lib/managers/adapters";
 import type { FileEventItemSentinel } from "@lib/managers/StorageEventManager";
 import type { NodeFile, NodeFolder } from "../adapters/NodeTypes";
+import type { Stats } from "fs";
 import * as fs from "fs/promises";
 import * as path from "path";
+import { watch as chokidarWatch, type FSWatcher } from "chokidar";
+import type { IgnoreRules } from "../serviceModules/IgnoreRules";
 
 /**
  * CLI-specific type guard adapter
@@ -56,22 +59,11 @@ class CLIPersistenceAdapter implements IStorageEventPersistenceAdapter {
 }
 
 /**
- * CLI-specific status adapter (console logging)
+ * CLI-specific status adapter (no-op — daemon uses journald for status)
  */
 class CLIStatusAdapter implements IStorageEventStatusAdapter {
-    private lastUpdate = 0;
-    private updateInterval = 5000; // Update every 5 seconds
-
-    updateStatus(status: { batched: number; processing: number; totalQueued: number }): void {
-        const now = Date.now();
-        if (now - this.lastUpdate > this.updateInterval) {
-            if (status.totalQueued > 0 || status.processing > 0) {
-                // console.log(
-                //     `[StorageEventManager] Batched: ${status.batched}, Processing: ${status.processing}, Total Queued: ${status.totalQueued}`
-                // );
-            }
-            this.lastUpdate = now;
-        }
+    updateStatus(_status: { batched: number; processing: number; totalQueued: number }): void {
+        // intentional no-op
     }
 }
 
@@ -100,15 +92,101 @@ class CLIConverterAdapter implements IStorageEventConverterAdapter<NodeFile> {
 }
 
 /**
- * CLI-specific watch adapter (optional file watching with chokidar)
+ * CLI-specific watch adapter using chokidar for real-time filesystem monitoring.
  */
 class CLIWatchAdapter implements IStorageEventWatchAdapter {
-    constructor(private basePath: string) {}
+    private _watcher: FSWatcher | undefined;
+
+    constructor(
+        private basePath: string,
+        private ignoreRules?: IgnoreRules,
+        private watchEnabled: boolean = false
+    ) {}
+
+    private _toNodeFile(filePath: string, stats: Stats | undefined): NodeFile {
+        return {
+            path: path.relative(this.basePath, filePath) as FilePath,
+            stat: {
+                ctime: stats?.ctimeMs ?? Date.now(),
+                mtime: stats?.mtimeMs ?? Date.now(),
+                size: stats?.size ?? 0,
+                type: "file",
+            },
+        };
+    }
+
+    private _toNodeFolder(dirPath: string): NodeFolder {
+        return {
+            path: path.relative(this.basePath, dirPath) as FilePath,
+            isFolder: true,
+        };
+    }
 
     async beginWatch(handlers: IStorageEventWatchHandlers): Promise<void> {
-        // File watching is not activated in the CLI.
-        // Because the CLI is designed for push/pull operations, not real-time sync.
-        // console.error("[CLIWatchAdapter] File watching is not enabled in CLI version");
+        if (!this.watchEnabled) return;
+        const baseIgnored: Array<RegExp | string | ((p: string) => boolean)> = [
+            /(^|[/\\])\./,
+            /(^|[/\\])[^/\\]*-livesync-v2([/\\]|$)/,
+        ];
+        // Bind rules to a local const before the closure — chokidar v4 requires a
+        // MatchFunction, not glob strings, for custom patterns.
+        const rules = this.ignoreRules;
+        const ignored = rules
+            ? [...baseIgnored, (p: string) => rules.shouldIgnore(path.relative(this.basePath, p))]
+            : baseIgnored;
+
+        const watcher = chokidarWatch(this.basePath, {
+            ignored,
+            ignoreInitial: true,
+            persistent: true,
+            awaitWriteFinish: {
+                stabilityThreshold: 500,
+                pollInterval: 100,
+            },
+        });
+
+        watcher.on("add", (filePath, stats) => {
+            const nodeFile = this._toNodeFile(filePath, stats);
+            handlers.onCreate(nodeFile);
+        });
+
+        watcher.on("change", (filePath, stats) => {
+            const nodeFile = this._toNodeFile(filePath, stats);
+            handlers.onChange(nodeFile);
+        });
+
+        watcher.on("unlink", (filePath) => {
+            const nodeFile = this._toNodeFile(filePath, undefined);
+            handlers.onDelete(nodeFile);
+        });
+
+        watcher.on("addDir", (dirPath) => {
+            const nodeFolder = this._toNodeFolder(dirPath);
+            handlers.onCreate(nodeFolder);
+        });
+
+        watcher.on("unlinkDir", (dirPath) => {
+            const nodeFolder = this._toNodeFolder(dirPath);
+            handlers.onDelete(nodeFolder);
+        });
+
+        watcher.on("error", (err) => {
+            console.error("[CLIWatchAdapter] Fatal watcher error — file watching stopped:", err);
+            console.error("[CLIWatchAdapter] Exiting for systemd restart.");
+            void watcher.close();
+            this._watcher = undefined;
+            // Use exit(1) rather than SIGTERM so systemd Restart=on-failure engages.
+            process.exit(1);
+        });
+
+        await new Promise<void>((resolve) => watcher.once("ready", resolve));
+        this._watcher = watcher;
+    }
+
+    close(): Promise<void> {
+        if (this._watcher) {
+            return this._watcher.close();
+        }
         return Promise.resolve();
     }
 }
@@ -123,11 +201,15 @@ export class CLIStorageEventManagerAdapter implements IStorageEventManagerAdapte
     readonly status: CLIStatusAdapter;
     readonly converter: CLIConverterAdapter;
 
-    constructor(basePath: string) {
+    constructor(basePath: string, ignoreRules?: IgnoreRules, watchEnabled: boolean = false) {
         this.typeGuard = new CLITypeGuardAdapter();
         this.persistence = new CLIPersistenceAdapter(basePath);
-        this.watch = new CLIWatchAdapter(basePath);
+        this.watch = new CLIWatchAdapter(basePath, ignoreRules, watchEnabled);
         this.status = new CLIStatusAdapter();
         this.converter = new CLIConverterAdapter();
     }
+
+    close(): Promise<void> {
+        return this.watch.close();
+    }
 }

src/apps/cli/managers/CLIStorageEventManagerAdapter.unit.spec.ts

@@ -0,0 +1,123 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import type { IStorageEventWatchHandlers } from "@lib/managers/adapters";
+import type { NodeFile } from "../adapters/NodeTypes";
+
+// ── chokidar mock ──────────────────────────────────────────────────────────────
+// Must be hoisted before imports that pull in chokidar.
+
+const mockWatcher = {
+    on: vi.fn().mockReturnThis(),
+    once: vi.fn((event: string, cb: () => void) => {
+        if (event === "ready") cb();
+        return mockWatcher;
+    }),
+    close: vi.fn(() => Promise.resolve()),
+};
+
+vi.mock("chokidar", () => ({
+    watch: vi.fn(() => mockWatcher),
+}));
+
+import * as chokidar from "chokidar";
+import { CLIStorageEventManagerAdapter } from "./CLIStorageEventManagerAdapter";
+
+// ── helpers ───────────────────────────────────────────────────────────────────
+
+function makeHandlers(): IStorageEventWatchHandlers {
+    return {
+        onCreate: vi.fn(),
+        onChange: vi.fn(),
+        onDelete: vi.fn(),
+        onRename: vi.fn(),
+    } as any;
+}
+
+// ── tests ─────────────────────────────────────────────────────────────────────
+
+describe("CLIStorageEventManagerAdapter", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // Restore the default once() behaviour (ready fires synchronously).
+        mockWatcher.once.mockImplementation((event: string, cb: () => void) => {
+            if (event === "ready") cb();
+            return mockWatcher;
+        });
+    });
+
+    it("beginWatch is no-op when watchEnabled=false", async () => {
+        const adapter = new CLIStorageEventManagerAdapter("/base", undefined, false);
+        const handlers = makeHandlers();
+
+        await adapter.watch.beginWatch(handlers);
+
+        expect(chokidar.watch).not.toHaveBeenCalled();
+    });
+
+    it("beginWatch calls chokidar.watch when watchEnabled=true", async () => {
+        const adapter = new CLIStorageEventManagerAdapter("/base", undefined, true);
+        const handlers = makeHandlers();
+
+        await adapter.watch.beginWatch(handlers);
+
+        expect(chokidar.watch).toHaveBeenCalledTimes(1);
+        expect(chokidar.watch).toHaveBeenCalledWith("/base", expect.objectContaining({ ignoreInitial: true }));
+    });
+
+    it("add event produces NodeFile with correct relative path via onCreate", async () => {
+        const basePath = "/vault/base";
+        const adapter = new CLIStorageEventManagerAdapter(basePath, undefined, true);
+        const handlers = makeHandlers();
+
+        await adapter.watch.beginWatch(handlers);
+
+        // Find the callback registered for the "add" event.
+        const addCall = mockWatcher.on.mock.calls.find(([event]) => event === "add");
+        expect(addCall).toBeDefined();
+        const addCallback = addCall![1] as (filePath: string, stats: any) => void;
+
+        const fakeStats = { ctimeMs: 1000, mtimeMs: 2000, size: 42 };
+        addCallback(`${basePath}/subdir/note.md`, fakeStats);
+
+        expect(handlers.onCreate).toHaveBeenCalledTimes(1);
+        const created = (handlers.onCreate as ReturnType<typeof vi.fn>).mock.calls[0][0] as NodeFile;
+        expect(created.path).toBe("subdir/note.md");
+        expect(created.stat?.size).toBe(42);
+    });
+
+    it("close() calls watcher.close()", async () => {
+        const adapter = new CLIStorageEventManagerAdapter("/base", undefined, true);
+        const handlers = makeHandlers();
+
+        await adapter.watch.beginWatch(handlers);
+        await adapter.close();
+
+        expect(mockWatcher.close).toHaveBeenCalledTimes(1);
+    });
+
+    it("close() is safe when no watcher was started", async () => {
+        const adapter = new CLIStorageEventManagerAdapter("/base", undefined, false);
+
+        // Should not throw.
+        await expect(adapter.close()).resolves.toBeUndefined();
+        expect(mockWatcher.close).not.toHaveBeenCalled();
+    });
+
+    it("error event triggers process.exit(1)", async () => {
+        const adapter = new CLIStorageEventManagerAdapter("/base", undefined, true);
+        const handlers = makeHandlers();
+
+        await adapter.watch.beginWatch(handlers);
+
+        const processExitSpy = vi.spyOn(process, "exit").mockImplementation((() => {}) as any);
+
+        const errorCall = mockWatcher.on.mock.calls.find(([event]) => event === "error");
+        expect(errorCall).toBeDefined();
+        const errorCallback = errorCall![1] as (err: Error) => void;
+
+        errorCallback(new Error("disk failure"));
+
+        expect(processExitSpy).toHaveBeenCalledWith(1);
+
+        processExitSpy.mockRestore();
+    });
+});

src/apps/cli/managers/StorageEventManagerCLI.ts

@@ -2,6 +2,7 @@ import { StorageEventManagerBase, type StorageEventManagerBaseDependencies } fro
 import { CLIStorageEventManagerAdapter } from "./CLIStorageEventManagerAdapter";
 import type { IMinimumLiveSyncCommands, LiveSyncBaseCore } from "../../../LiveSyncBaseCore";
 import type { ServiceContext } from "@lib/services/base/ServiceBase";
+import type { IgnoreRules } from "../serviceModules/IgnoreRules";
 // import type { IMinimumLiveSyncCommands } from "@lib/services/base/IService";
 
 export class StorageEventManagerCLI extends StorageEventManagerBase<CLIStorageEventManagerAdapter> {
@@ -10,9 +11,11 @@ export class StorageEventManagerCLI extends StorageEventManagerBase<CLIStorageEv
     constructor(
         basePath: string,
         core: LiveSyncBaseCore<ServiceContext, IMinimumLiveSyncCommands>,
-        dependencies: StorageEventManagerBaseDependencies
+        dependencies: StorageEventManagerBaseDependencies,
+        ignoreRules?: IgnoreRules,
+        watchEnabled?: boolean
     ) {
-        const adapter = new CLIStorageEventManagerAdapter(basePath);
+        const adapter = new CLIStorageEventManagerAdapter(basePath, ignoreRules, watchEnabled);
         super(adapter, dependencies);
         this.core = core;
     }
@@ -25,4 +28,11 @@ export class StorageEventManagerCLI extends StorageEventManagerBase<CLIStorageEv
         // No-op in CLI version
         // Internal file handling is not needed
     }
+
+    /**
+     * Close the file watcher. Call this during graceful shutdown.
+     */
+    close(): Promise<void> {
+        return this.adapter.close();
+    }
 }

src/apps/cli/package.json

@@ -6,6 +6,7 @@
     "type": "module",
     "scripts": {
         "dev": "vite",
+        "prebuild": "node scripts/check-submodule.mjs",
         "build": "vite build",
         "preview": "vite preview",
         "cli": "node dist/index.cjs",

src/apps/cli/runtime-package.json

@@ -4,6 +4,7 @@
     "version": "0.0.0",
     "description": "Runtime dependencies for Self-hosted LiveSync CLI Docker image",
     "dependencies": {
+        "chokidar": "^4.0.0",
         "commander": "^14.0.3",
         "werift": "^0.22.9",
         "pouchdb-adapter-http": "^9.0.0",

src/apps/cli/scripts/check-submodule.mjs

@@ -0,0 +1,36 @@
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+
+const cliDir = process.cwd();
+const repoRoot = path.resolve(cliDir, "../../..");
+const requiredFiles = [
+    path.join(repoRoot, "src/lib/src/common/types.ts"),
+];
+
+const missingFiles = requiredFiles.filter((filePath) => !fs.existsSync(filePath));
+
+if (missingFiles.length === 0) {
+    process.exit(0);
+}
+
+console.error("[CLI Build Error] Required shared sources were not found.");
+console.error("This repository uses Git submodules, and the CLI depends on src/lib.");
+console.error("");
+console.error("Missing file(s):");
+for (const filePath of missingFiles) {
+    console.error(`  - ${path.relative(repoRoot, filePath)}`);
+}
+console.error("");
+console.error("Initialize submodules, then retry the CLI build:");
+console.error("  git submodule update --init --recursive");
+console.error("");
+console.error("For a fresh clone, prefer:");
+console.error("  git clone --recurse-submodules <repository-url>");
+console.error("");
+console.error("Then run:");
+console.error("  npm install");
+console.error("  cd src/apps/cli");
+console.error("  npm run build");
+
+process.exit(1);

src/apps/cli/serviceModules/CLIServiceModules.ts

@@ -9,6 +9,7 @@ import { ServiceFileAccessCLI } from "./ServiceFileAccessImpl";
 import { ServiceDatabaseFileAccessCLI } from "./DatabaseFileAccess";
 import { StorageEventManagerCLI } from "../managers/StorageEventManagerCLI";
 import type { ServiceModules } from "@lib/interfaces/ServiceModule";
+import type { IgnoreRules } from "./IgnoreRules";
 
 /**
  * Initialize service modules for CLI version
@@ -22,7 +23,9 @@ import type { ServiceModules } from "@lib/interfaces/ServiceModule";
 export function initialiseServiceModulesCLI(
     basePath: string,
     core: LiveSyncBaseCore<ServiceContext, any>,
-    services: InjectableServiceHub<ServiceContext>
+    services: InjectableServiceHub<ServiceContext>,
+    ignoreRules?: IgnoreRules,
+    watchEnabled: boolean = false
 ): ServiceModules {
     const storageAccessManager = new StorageAccessManager();
 
@@ -36,12 +39,24 @@ export function initialiseServiceModulesCLI(
     });
 
     // CLI-specific storage event manager
-    const storageEventManager = new StorageEventManagerCLI(basePath, core, {
-        fileProcessing: services.fileProcessing,
-        setting: services.setting,
-        vaultService: services.vault,
-        storageAccessManager: storageAccessManager,
-        APIService: services.API,
+    const storageEventManager = new StorageEventManagerCLI(
+        basePath,
+        core,
+        {
+            fileProcessing: services.fileProcessing,
+            setting: services.setting,
+            vaultService: services.vault,
+            storageAccessManager: storageAccessManager,
+            APIService: services.API,
+        },
+        ignoreRules,
+        watchEnabled
+    );
+
+    // Close the file watcher during graceful shutdown so the process can exit cleanly.
+    services.appLifecycle.onUnload.addHandler(async () => {
+        await storageEventManager.close();
+        return true;
     });
 
     // Storage access using CLI file system adapter

src/apps/cli/serviceModules/IgnoreRules.ts

@@ -0,0 +1,131 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+
+import { minimatch } from "minimatch";
+
+/**
+ * Loads and evaluates ignore rules from `.livesync/ignore` inside the vault.
+ *
+ * File format:
+ *   - Lines starting with `#` are comments.
+ *   - Blank lines are ignored.
+ *   - `import: .gitignore` (exactly) — merges patterns from the vault's `.gitignore`.
+ *   - All other lines are minimatch glob patterns relative to the vault root.
+ *
+ * Negation patterns (lines starting with `!`) are not supported. Loading a
+ * ruleset containing them throws an error — use separate include/exclude files
+ * instead.
+ *
+ * Missing files (`.livesync/ignore` or `.gitignore`) are silently skipped.
+ */
+export class IgnoreRules {
+    private patterns: string[] = [];
+
+    constructor(private vaultPath: string) {}
+
+    /**
+     * Reads `.livesync/ignore` (and optionally `.gitignore`) and populates the
+     * pattern list.  Safe to call multiple times — each call replaces the
+     * previous state.  Does not throw if files are absent.
+     *
+     * @throws if any pattern line begins with `!` (negation is unsupported).
+     */
+    async load(): Promise<void> {
+        this.patterns = [];
+        const ignorePath = path.join(this.vaultPath, ".livesync", "ignore");
+        let rawLines: string[];
+        try {
+            const content = await fs.readFile(ignorePath, "utf-8");
+            rawLines = content.split(/\r?\n/);
+        } catch {
+            // File absent or unreadable — treat as empty ruleset.
+            return;
+        }
+
+        for (const line of rawLines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("#")) {
+                continue;
+            }
+            // NOTE: Only the exact string "import: .gitignore" is recognised.
+            // Any future generalisation of this directive must validate that
+            // the resolved path stays within the vault directory.
+            if (trimmed === "import: .gitignore") {
+                await this._importGitignore();
+                continue;
+            }
+            if (trimmed.startsWith("import:")) {
+                console.error(
+                    `[IgnoreRules] Warning: unrecognised directive '${trimmed}' — only 'import: .gitignore' is supported`
+                );
+                continue;
+            }
+            this._addPattern(trimmed);
+        }
+        if (this.patterns.length > 0) {
+            console.error(`[IgnoreRules] Loaded ${this.patterns.length} ignore patterns`);
+        }
+    }
+
+    // Normalises a single gitignore-style pattern:
+    //   - Patterns ending with `/` (directory patterns like `build/`) are
+    //     converted to `build/**` so they match all files inside that directory.
+    //   - Patterns without a `/` are prefixed with `**/` to give them matchBase
+    //     semantics (e.g. `*.tmp` → `**/*.tmp`), matching the basename in any
+    //     subdirectory as gitignore does.
+    //   - Patterns that already contain a `/` (but don't end with one) are
+    //     path-specific and used as-is.
+    private _normalisePattern(pattern: string): string {
+        if (pattern.endsWith("/")) {
+            return "**/" + pattern + "**";
+        } else if (!pattern.includes("/")) {
+            return "**/" + pattern;
+        }
+        return pattern;
+    }
+
+    private async _importGitignore(): Promise<void> {
+        const gitignorePath = path.join(this.vaultPath, ".gitignore");
+        let content: string;
+        try {
+            content = await fs.readFile(gitignorePath, "utf-8");
+        } catch {
+            return;
+        }
+        this._parseLines(content);
+    }
+
+    private _parseLines(content: string): void {
+        for (const line of content.split(/\r?\n/)) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("#")) continue;
+            this._addPattern(trimmed);
+        }
+    }
+
+    private _addPattern(raw: string): void {
+        if (raw.startsWith("!")) {
+            throw new Error(
+                `[IgnoreRules] Negation pattern '${raw}' is not supported. ` +
+                    `Remove it from .livesync/ignore or use a separate include/exclude file.`
+            );
+        }
+        this.patterns.push(this._normalisePattern(raw));
+    }
+
+    /**
+     * Returns `true` if the given vault-relative path matches any loaded
+     * ignore pattern.
+     *
+     * @param relativePath - Path relative to the vault root, using forward
+     *   slashes or the OS separator.
+     */
+    shouldIgnore(relativePath: string): boolean {
+        if (this.patterns.length === 0) {
+            return false;
+        }
+        // Normalise to forward slashes for minimatch.
+        const normalised = relativePath.replace(/\\/g, "/");
+        return this.patterns.some((p) => minimatch(normalised, p, { dot: true }));
+    }
+}

src/apps/cli/serviceModules/IgnoreRules.unit.spec.ts

@@ -0,0 +1,169 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { IgnoreRules } from "./IgnoreRules";
+
+describe("IgnoreRules", () => {
+    const tempDirs: string[] = [];
+
+    async function createVault(): Promise<string> {
+        const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "livesync-ignorerules-"));
+        tempDirs.push(tempDir);
+        return tempDir;
+    }
+
+    async function writeIgnoreFile(vaultPath: string, content: string): Promise<void> {
+        const ignoreDir = path.join(vaultPath, ".livesync");
+        await fs.mkdir(ignoreDir, { recursive: true });
+        await fs.writeFile(path.join(ignoreDir, "ignore"), content, "utf-8");
+    }
+
+    afterEach(async () => {
+        await Promise.all(tempDirs.splice(0).map((dir) => fs.rm(dir, { recursive: true, force: true })));
+    });
+
+    describe("pattern normalisation", () => {
+        it("adds **/ prefix to basename patterns (no slash)", async () => {
+            const vaultPath = await createVault();
+            await writeIgnoreFile(vaultPath, "*.tmp\n");
+            const rules = new IgnoreRules(vaultPath);
+            await rules.load();
+            expect(rules.shouldIgnore("notes/scratch.tmp")).toBe(true);
+            expect(rules.shouldIgnore("scratch.tmp")).toBe(true);
+            expect(rules.shouldIgnore("deep/nested/file.tmp")).toBe(true);
+        });
+
+        it("appends ** to directory patterns ending with / and prepends **/", async () => {
+            const vaultPath = await createVault();
+            await writeIgnoreFile(vaultPath, "build/\n");
+            const rules = new IgnoreRules(vaultPath);
+            await rules.load();
+            expect(rules.shouldIgnore("build/output.js")).toBe(true);
+            expect(rules.shouldIgnore("build/nested/file.js")).toBe(true);
+            expect(rules.shouldIgnore("subproject/build/output.js")).toBe(true);
+        });
+
+        it("leaves patterns containing / as-is", async () => {
+            const vaultPath = await createVault();
+            await writeIgnoreFile(vaultPath, "docs/private.md\n");
+            const rules = new IgnoreRules(vaultPath);
+            await rules.load();
+            expect(rules.shouldIgnore("docs/private.md")).toBe(true);
+            expect(rules.shouldIgnore("other/docs/private.md")).toBe(false);
+        });
+    });
+
+    describe("shouldIgnore", () => {
+        it("matches **/*.tmp against notes/scratch.tmp", async () => {
+            const vaultPath = await createVault();
+            await writeIgnoreFile(vaultPath, "*.tmp\n");
+            const rules = new IgnoreRules(vaultPath);
+            await rules.load();
+            expect(rules.shouldIgnore("notes/scratch.tmp")).toBe(true);
+        });
+
+        it("does not match notes/readme.md against **/*.tmp", async () => {
+            const vaultPath = await createVault();
+            await writeIgnoreFile(vaultPath, "*.tmp\n");
+            const rules = new IgnoreRules(vaultPath);
+            await rules.load();
+            expect(rules.shouldIgnore("notes/readme.md")).toBe(false);
+        });
+
+        it("returns false when no patterns are loaded", async () => {
+            const vaultPath = await createVault();
+            const rules = new IgnoreRules(vaultPath);
+            // No load() call — patterns are empty
+            expect(rules.shouldIgnore("anything.md")).toBe(false);
+        });
+    });
+
+    describe("negation patterns", () => {
+        it("throws when a negation pattern is encountered", async () => {
+            const vaultPath = await createVault();
+            await writeIgnoreFile(vaultPath, "*.tmp\n!important.tmp\n");
+            const rules = new IgnoreRules(vaultPath);
+            await expect(rules.load()).rejects.toThrow(/Negation pattern/);
+        });
+
+        it("throws when a .gitignore imported via directive contains negation", async () => {
+            const vaultPath = await createVault();
+            await writeIgnoreFile(vaultPath, "import: .gitignore\n");
+            await fs.writeFile(path.join(vaultPath, ".gitignore"), "*.log\n!keep.log\n", "utf-8");
+            const rules = new IgnoreRules(vaultPath);
+            await expect(rules.load()).rejects.toThrow(/Negation pattern/);
+        });
+    });
+
+    describe("unrecognised import: directives", () => {
+        it("warns and skips unrecognised import: forms (does not add as literal pattern)", async () => {
+            const vaultPath = await createVault();
+            // Typo: "import:.gitignore" instead of "import: .gitignore"
+            await writeIgnoreFile(vaultPath, "*.tmp\nimport:.gitignore\n");
+            const rules = new IgnoreRules(vaultPath);
+            await rules.load();
+            // *.tmp still loaded; import:.gitignore is skipped (not treated as a literal pattern)
+            expect(rules.shouldIgnore("scratch.tmp")).toBe(true);
+            expect(rules.shouldIgnore("import:.gitignore")).toBe(false);
+        });
+    });
+
+    describe("load() with missing file", () => {
+        it("returns without error when .livesync/ignore is absent", async () => {
+            const vaultPath = await createVault();
+            // No ignore file created
+            const rules = new IgnoreRules(vaultPath);
+            await expect(rules.load()).resolves.toBeUndefined();
+            expect(rules.shouldIgnore("anything.md")).toBe(false);
+        });
+    });
+
+    describe("load() with comments and blank lines", () => {
+        it("skips # comment lines and blank lines", async () => {
+            const vaultPath = await createVault();
+            await writeIgnoreFile(vaultPath, "# This is a comment\n\n  \n*.tmp\n# another comment\nbuild/\n");
+            const rules = new IgnoreRules(vaultPath);
+            await rules.load();
+            expect(rules.shouldIgnore("scratch.tmp")).toBe(true);
+            expect(rules.shouldIgnore("build/output.js")).toBe(true);
+            expect(rules.shouldIgnore("readme.md")).toBe(false);
+        });
+    });
+
+    describe("import: .gitignore directive", () => {
+        it("reads and normalises patterns from .gitignore", async () => {
+            const vaultPath = await createVault();
+            await writeIgnoreFile(vaultPath, "import: .gitignore\n");
+            await fs.writeFile(path.join(vaultPath, ".gitignore"), "*.log\nnode_modules/\n", "utf-8");
+            const rules = new IgnoreRules(vaultPath);
+            await rules.load();
+            expect(rules.shouldIgnore("app.log")).toBe(true);
+            expect(rules.shouldIgnore("node_modules/package.json")).toBe(true);
+            expect(rules.shouldIgnore("src/node_modules/package.json")).toBe(true);
+            expect(rules.shouldIgnore("src/index.ts")).toBe(false);
+        });
+
+        it("merges .gitignore patterns with other patterns", async () => {
+            const vaultPath = await createVault();
+            await writeIgnoreFile(vaultPath, "*.tmp\nimport: .gitignore\n");
+            await fs.writeFile(path.join(vaultPath, ".gitignore"), "*.log\n", "utf-8");
+            const rules = new IgnoreRules(vaultPath);
+            await rules.load();
+            expect(rules.shouldIgnore("scratch.tmp")).toBe(true);
+            expect(rules.shouldIgnore("error.log")).toBe(true);
+        });
+    });
+
+    describe("import: .gitignore with missing .gitignore", () => {
+        it("does not throw when .gitignore is absent", async () => {
+            const vaultPath = await createVault();
+            await writeIgnoreFile(vaultPath, "*.tmp\nimport: .gitignore\n");
+            // No .gitignore created
+            const rules = new IgnoreRules(vaultPath);
+            await expect(rules.load()).resolves.toBeUndefined();
+            // The *.tmp pattern from the ignore file still works
+            expect(rules.shouldIgnore("scratch.tmp")).toBe(true);
+        });
+    });
+});

src/apps/cli/test/test-daemon-linux.sh

@@ -0,0 +1,166 @@
+#!/usr/bin/env bash
+# Test: daemon-related ignore rules behaviour
+#
+# Tests that are runnable without a long-running daemon process are exercised
+# here using the `mirror` command, which calls the same `isTargetFile` handler
+# stack that the daemon uses.
+#
+# Covered cases:
+#   1. .livesync/ignore with *.tmp pattern  → ignored file is NOT synced to DB
+#   2. .livesync/ignore missing             → no error, normal sync continues
+#   3. import: .gitignore directive         → patterns from .gitignore are merged
+#
+set -euo pipefail
+
+SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
+CLI_DIR="$(cd -- "$SCRIPT_DIR/.." && pwd)"
+cd "$CLI_DIR"
+source "$SCRIPT_DIR/test-helpers.sh"
+display_test_info
+
+RUN_BUILD="${RUN_BUILD:-1}"
+cli_test_init_cli_cmd
+
+WORK_DIR="$(mktemp -d "${TMPDIR:-/tmp}/livesync-cli-daemon-test.XXXXXX")"
+trap 'rm -rf "$WORK_DIR"' EXIT
+
+SETTINGS_FILE="$WORK_DIR/data.json"
+VAULT_DIR="$WORK_DIR/vault"
+mkdir -p "$VAULT_DIR/notes"
+
+if [[ "$RUN_BUILD" == "1" ]]; then
+    echo "[INFO] building CLI..."
+    npm run build
+fi
+
+echo "[INFO] generating settings -> $SETTINGS_FILE"
+cli_test_init_settings_file "$SETTINGS_FILE"
+cli_test_mark_settings_configured "$SETTINGS_FILE"
+
+PASS=0
+FAIL=0
+
+assert_pass() { echo "[PASS] $1"; PASS=$((PASS + 1)); }
+assert_fail() { echo "[FAIL] $1" >&2; FAIL=$((FAIL + 1)); }
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Case 1: .livesync/ignore with *.tmp → matched file should NOT appear in DB
+# ─────────────────────────────────────────────────────────────────────────────
+echo ""
+echo "=== Case 1: .livesync/ignore *.tmp → ignored file not synced to DB ==="
+
+mkdir -p "$VAULT_DIR/.livesync"
+printf '*.tmp\n' > "$VAULT_DIR/.livesync/ignore"
+
+# Also write a normal file so we can confirm mirror ran at all.
+printf 'normal content\n' > "$VAULT_DIR/notes/normal.md"
+# Write the file that should be ignored.
+printf 'tmp content\n' > "$VAULT_DIR/notes/scratch.tmp"
+
+run_cli "$VAULT_DIR" --settings "$SETTINGS_FILE" mirror
+
+# The normal file should be in the DB.
+RESULT_NORMAL="$WORK_DIR/case1-normal.txt"
+if run_cli "$VAULT_DIR" --settings "$SETTINGS_FILE" pull notes/normal.md "$RESULT_NORMAL" 2>/dev/null; then
+    if cmp -s "$VAULT_DIR/notes/normal.md" "$RESULT_NORMAL"; then
+        assert_pass "normal.md was synced to DB"
+    else
+        assert_fail "normal.md content mismatch after mirror"
+    fi
+else
+    assert_fail "normal.md was not found in DB after mirror"
+fi
+
+# The .tmp file should NOT be in the DB.
+DB_LIST="$WORK_DIR/case1-ls.txt"
+run_cli "$VAULT_DIR" --settings "$SETTINGS_FILE" ls > "$DB_LIST"
+if grep -q "scratch.tmp" "$DB_LIST"; then
+    assert_fail "scratch.tmp (ignored) was unexpectedly synced to DB"
+    echo "--- DB listing ---" >&2; cat "$DB_LIST" >&2
+else
+    assert_pass "scratch.tmp (*.tmp pattern) was NOT synced to DB"
+fi
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Case 2: .livesync/ignore absent → no error, normal sync continues
+# ─────────────────────────────────────────────────────────────────────────────
+echo ""
+echo "=== Case 2: .livesync/ignore absent → no error, sync continues ==="
+
+VAULT_DIR2="$WORK_DIR/vault2"
+mkdir -p "$VAULT_DIR2/notes"
+SETTINGS_FILE2="$WORK_DIR/data2.json"
+cli_test_init_settings_file "$SETTINGS_FILE2"
+cli_test_mark_settings_configured "$SETTINGS_FILE2"
+
+# No .livesync directory at all.
+printf 'hello\n' > "$VAULT_DIR2/notes/hello.md"
+
+# mirror should succeed without error.
+set +e
+MIRROR_OUTPUT="$WORK_DIR/case2-mirror.txt"
+run_cli "$VAULT_DIR2" --settings "$SETTINGS_FILE2" mirror >"$MIRROR_OUTPUT" 2>&1
+MIRROR_EXIT=$?
+set -e
+
+if [[ "$MIRROR_EXIT" -ne 0 ]]; then
+    assert_fail "mirror exited non-zero ($MIRROR_EXIT) when .livesync/ignore is absent"
+    cat "$MIRROR_OUTPUT" >&2
+else
+    assert_pass "mirror succeeded when .livesync/ignore is absent"
+fi
+
+# The normal file should have been synced.
+RESULT_HELLO="$WORK_DIR/case2-hello.txt"
+if run_cli "$VAULT_DIR2" --settings "$SETTINGS_FILE2" pull notes/hello.md "$RESULT_HELLO" 2>/dev/null; then
+    assert_pass "file synced normally when .livesync/ignore is absent"
+else
+    assert_fail "file was not synced when .livesync/ignore is absent"
+fi
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Case 3: import: .gitignore merges patterns
+# ─────────────────────────────────────────────────────────────────────────────
+echo ""
+echo "=== Case 3: import: .gitignore directive merges patterns ==="
+
+VAULT_DIR3="$WORK_DIR/vault3"
+mkdir -p "$VAULT_DIR3/notes"
+SETTINGS_FILE3="$WORK_DIR/data3.json"
+cli_test_init_settings_file "$SETTINGS_FILE3"
+cli_test_mark_settings_configured "$SETTINGS_FILE3"
+
+mkdir -p "$VAULT_DIR3/.livesync"
+printf 'import: .gitignore\n' > "$VAULT_DIR3/.livesync/ignore"
+printf '# gitignore comment\n*.log\nbuild/\n' > "$VAULT_DIR3/.gitignore"
+
+printf 'regular note\n' > "$VAULT_DIR3/notes/regular.md"
+printf 'log content\n' > "$VAULT_DIR3/notes/debug.log"
+
+run_cli "$VAULT_DIR3" --settings "$SETTINGS_FILE3" mirror
+
+DB_LIST3="$WORK_DIR/case3-ls.txt"
+run_cli "$VAULT_DIR3" --settings "$SETTINGS_FILE3" ls > "$DB_LIST3"
+
+if grep -q "debug.log" "$DB_LIST3"; then
+    assert_fail "debug.log (ignored via .gitignore import) was unexpectedly synced to DB"
+    echo "--- DB listing ---" >&2; cat "$DB_LIST3" >&2
+else
+    assert_pass "debug.log (*.log from imported .gitignore) was NOT synced to DB"
+fi
+
+# regular.md should still be present.
+if grep -q "regular.md" "$DB_LIST3"; then
+    assert_pass "regular.md was synced normally alongside .gitignore import rules"
+else
+    assert_fail "regular.md was NOT synced — .gitignore import may have been too broad"
+fi
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Summary
+# ─────────────────────────────────────────────────────────────────────────────
+echo ""
+echo "Results: PASS=$PASS FAIL=$FAIL"
+if [[ "$FAIL" -gt 0 ]]; then
+    exit 1
+fi

src/apps/cli/testdeno/.test.env

@@ -0,0 +1,9 @@
+hostname=http://127.0.0.1:5989/
+dbname=livesync-test-db-ci
+username=admin
+password=testpassword
+minioEndpoint=http://127.0.0.1:9000
+accessKey=minioadmin
+secretKey=minioadmin
+bucketName=livesync-test-bucket-ci
+LIVESYNC_TEST_TEE=1

src/apps/cli/testdeno/deno.json

@@ -1,19 +1,19 @@
 {
     "tasks": {
-        "test": "deno test -A --no-check test-*.ts",
-        "test:local": "deno test -A --no-check test-setup-put-cat.ts test-mirror.ts",
-        "test:push-pull": "deno test -A --no-check test-push-pull.ts",
-        "test:setup-put-cat": "deno test -A --no-check test-setup-put-cat.ts",
-        "test:mirror": "deno test -A --no-check test-mirror.ts",
-        "test:sync-two-local": "deno test -A --no-check test-sync-two-local-databases.ts",
-        "test:sync-locked-remote": "deno test -A --no-check test-sync-locked-remote.ts",
-        "test:p2p-host": "deno test -A --no-check test-p2p-host.ts",
-        "test:p2p-peers": "deno test -A --no-check test-p2p-peers-local-relay.ts",
-        "test:p2p-sync": "deno test -A --no-check test-p2p-sync.ts",
-        "test:p2p-three-nodes": "deno test -A --no-check test-p2p-three-nodes-conflict.ts",
-        "test:p2p-upload-download": "deno test -A --no-check test-p2p-upload-download-repro.ts",
-        "test:e2e-couchdb": "deno test -A --no-check test-e2e-two-vaults-couchdb.ts",
-        "test:e2e-matrix": "deno test -A --no-check test-e2e-two-vaults-matrix.ts"
+        "test": "deno test --env-file=.test.env -A --no-check test-*.ts",
+        "test:local": "deno test --env-file=.test.env -A --no-check test-setup-put-cat.ts test-mirror.ts",
+        "test:push-pull": "deno test --env-file=.test.env -A --no-check test-push-pull.ts",
+        "test:setup-put-cat": "deno test --env-file=.test.env -A --no-check test-setup-put-cat.ts",
+        "test:mirror": "deno test --env-file=.test.env -A --no-check test-mirror.ts",
+        "test:sync-two-local": "deno test --env-file=.test.env -A --no-check test-sync-two-local-databases.ts",
+        "test:sync-locked-remote": "deno test --env-file=.test.env -A --no-check test-sync-locked-remote.ts",
+        "test:p2p-host": "deno test --env-file=.test.env -A --no-check test-p2p-host.ts",
+        "test:p2p-peers": "deno test --env-file=.test.env -A --no-check test-p2p-peers-local-relay.ts",
+        "test:p2p-sync": "deno test --env-file=.test.env -A --no-check test-p2p-sync.ts",
+        "test:p2p-three-nodes": "deno test --env-file=.test.env -A --no-check test-p2p-three-nodes-conflict.ts",
+        "test:p2p-upload-download": "deno test --env-file=.test.env -A --no-check test-p2p-upload-download-repro.ts",
+        "test:e2e-couchdb": "deno test --env-file=.test.env -A --no-check test-e2e-two-vaults-couchdb.ts",
+        "test:e2e-matrix": "deno test --env-file=.test.env -A --no-check test-e2e-two-vaults-matrix.ts"
     },
     "imports": {
         "@std/assert": "jsr:@std/assert@^1.0.13",

src/apps/cli/testdeno/test-e2e-two-vaults-couchdb.ts

@@ -1,6 +1,5 @@
 import { assert } from "@std/assert";
 import { TempDir } from "./helpers/temp.ts";
-import { loadEnvFile } from "./helpers/env.ts";
 import {
     runCli,
     runCliOrFail,
@@ -11,31 +10,30 @@ import {
 } from "./helpers/cli.ts";
 import { applyRemoteSyncSettings, initSettingsFile } from "./helpers/settings.ts";
 import { startCouchdb, startMinio, stopCouchdb, stopMinio } from "./helpers/docker.ts";
-import { join } from "@std/path";
-
-const TEST_ENV = join(import.meta.dirname!, "..", ".test.env");
 type RemoteType = "COUCHDB" | "MINIO";
 
-function requireEnv(env: Record<string, string>, key: string): string {
-    const value = env[key]?.trim();
-    if (!value) throw new Error(`Required env var is missing: ${key}`);
-    return value;
+function requireEnv(...keys: string[]): string {
+    for (const key of keys) {
+        const value = Deno.env.get(key)?.trim();
+        if (value) return value;
+    }
+    throw new Error(`Required env var is missing: ${keys.join(" or ")}`);
 }
 
 export async function runScenario(remoteType: RemoteType, encrypt: boolean): Promise<void> {
-    const env = await loadEnvFile(TEST_ENV);
     const dbSuffix = `${Date.now()}-${Math.floor(Math.random() * 100000)}`;
 
-    const couchdbUri = remoteType === "COUCHDB" ? requireEnv(env, "hostname").replace(/\/$/, "") : "";
-    const couchdbUser = remoteType === "COUCHDB" ? requireEnv(env, "username") : "";
-    const couchdbPassword = remoteType === "COUCHDB" ? requireEnv(env, "password") : "";
-    const dbPrefix = remoteType === "COUCHDB" ? requireEnv(env, "dbname") : "";
+    const couchdbUri = remoteType === "COUCHDB" ? requireEnv("COUCHDB_URI", "hostname").replace(/\/$/, "") : "";
+    const couchdbUser = remoteType === "COUCHDB" ? requireEnv("COUCHDB_USER", "username") : "";
+    const couchdbPassword = remoteType === "COUCHDB" ? requireEnv("COUCHDB_PASSWORD", "password") : "";
+    const dbPrefix = remoteType === "COUCHDB" ? requireEnv("COUCHDB_DBNAME", "dbname") : "";
     const dbname = remoteType === "COUCHDB" ? `${dbPrefix}-${dbSuffix}` : "";
 
-    const minioEndpoint = remoteType === "MINIO" ? requireEnv(env, "minioEndpoint").replace(/\/$/, "") : "";
-    const minioAccessKey = remoteType === "MINIO" ? requireEnv(env, "accessKey") : "";
-    const minioSecretKey = remoteType === "MINIO" ? requireEnv(env, "secretKey") : "";
-    const minioBucketBase = remoteType === "MINIO" ? requireEnv(env, "bucketName") : "";
+    const minioEndpoint =
+        remoteType === "MINIO" ? requireEnv("MINIO_ENDPOINT", "minioEndpoint").replace(/\/$/, "") : "";
+    const minioAccessKey = remoteType === "MINIO" ? requireEnv("MINIO_ACCESS_KEY", "accessKey") : "";
+    const minioSecretKey = remoteType === "MINIO" ? requireEnv("MINIO_SECRET_KEY", "secretKey") : "";
+    const minioBucketBase = remoteType === "MINIO" ? requireEnv("MINIO_BUCKET_NAME", "bucketName") : "";
     const minioBucket = remoteType === "MINIO" ? `${minioBucketBase}-${dbSuffix}` : "";
 
     const passphrase = "e2e-passphrase";

src/apps/cli/testdeno/test-sync-locked-remote.ts

@@ -6,30 +6,26 @@
  */
 
 import { assert, assertStringIncludes } from "@std/assert";
-import { join } from "@std/path";
-import { loadEnvFile } from "./helpers/env.ts";
 import { TempDir } from "./helpers/temp.ts";
 import { runCli } from "./helpers/cli.ts";
 import { applyCouchdbSettings, initSettingsFile } from "./helpers/settings.ts";
 import { createCouchdbDatabase, startCouchdb, stopCouchdb, updateCouchdbDoc } from "./helpers/docker.ts";
 
-const TEST_ENV = join(import.meta.dirname!, "..", ".test.env");
 const MILESTONE_DOC = "_local/obsydian_livesync_milestone";
 
-function requireEnv(env: Record<string, string>, key: string): string {
-    const value = env[key]?.trim();
-    if (!value) {
-        throw new Error(`Required env var is missing: ${key}`);
+function requireEnv(...keys: string[]): string {
+    for (const key of keys) {
+        const value = Deno.env.get(key)?.trim();
+        if (value) return value;
     }
-    return value;
+    throw new Error(`Required env var is missing: ${keys.join(" or ")}`);
 }
 
 Deno.test("sync: actionable error against locked remote DB", async () => {
-    const env = await loadEnvFile(TEST_ENV);
-    const couchdbUri = requireEnv(env, "hostname").replace(/\/$/, "");
-    const couchdbUser = requireEnv(env, "username");
-    const couchdbPassword = requireEnv(env, "password");
-    const dbPrefix = requireEnv(env, "dbname");
+    const couchdbUri = requireEnv("COUCHDB_URI", "hostname").replace(/\/$/, "");
+    const couchdbUser = requireEnv("COUCHDB_USER", "username");
+    const couchdbPassword = requireEnv("COUCHDB_PASSWORD", "password");
+    const dbPrefix = requireEnv("COUCHDB_DBNAME", "dbname");
     const dbname = `${dbPrefix}-locked-${Date.now()}-${Math.floor(Math.random() * 100000)}`;
 
     await using workDir = await TempDir.create("livesync-cli-locked-test");

src/apps/cli/testdeno/test-sync-two-local-databases.ts

@@ -23,13 +23,11 @@
  *   deno test -A test-sync-two-local-databases.ts
  */
 
-import { join } from "@std/path";
 import { assertEquals, assert } from "@std/assert";
 import { TempDir } from "./helpers/temp.ts";
-import { CLI_DIR, runCliOrFail, jsonFieldIsNa } from "./helpers/cli.ts";
+import { runCliOrFail, jsonFieldIsNa } from "./helpers/cli.ts";
 import { applyCouchdbSettings, initSettingsFile } from "./helpers/settings.ts";
 import { startCouchdb, stopCouchdb } from "./helpers/docker.ts";
-import { loadEnvFile } from "./helpers/env.ts";
 
 // ---------------------------------------------------------------------------
 // Load configuration
@@ -41,20 +39,7 @@ async function resolveConfig(): Promise<{
     password: string;
     baseDbname: string;
 } | null> {
-    let env: Record<string, string> = {};
-
-    // 1. Explicit environment variables take priority
-    if (Deno.env.get("COUCHDB_URI")) {
-        env = Object.fromEntries(Deno.env.toObject());
-    } else {
-        // 2. TEST_ENV_FILE env var
-        const envFile = Deno.env.get("TEST_ENV_FILE") ?? join(CLI_DIR, ".test.env");
-        try {
-            env = await loadEnvFile(envFile);
-        } catch {
-            return null; // no config available — skip
-        }
-    }
+    const env = Deno.env.toObject();
 
     const uri = (env["COUCHDB_URI"] ?? env["hostname"] ?? "").replace(/\/$/, "");
     const user = env["COUCHDB_USER"] ?? env["username"] ?? "";

src/apps/cli/vite.config.ts

@@ -11,11 +11,55 @@ const defaultExternal = [
     "crypto",
     "pouchdb-adapter-leveldb",
     "commander",
+    "chokidar",
     "punycode",
     "werift",
 ];
+// Polyfill FileReader at the very top of the CJS bundle. octagonal-wheels uses
+// FileReader for base64 conversion when Uint8Array.toBase64 (TC39 proposal) is
+// unavailable. Node.js has neither, so we inject a minimal FileReader shim before
+// any module-scope code evaluates.
+const fileReaderPolyfillBanner = `
+if (typeof globalThis.FileReader === "undefined") {
+    globalThis.FileReader = class FileReader {
+        constructor() { this.result = null; this.onload = null; this.onerror = null; }
+        readAsDataURL(blob) {
+            blob.arrayBuffer().then((buf) => {
+                var b64 = require("buffer").Buffer.from(buf).toString("base64");
+                this.result = "data:" + (blob.type || "application/octet-stream") + ";base64," + b64;
+                if (this.onload) this.onload({ target: this });
+            }).catch((err) => { if (this.onerror) this.onerror({ target: this, error: err }); });
+        }
+        readAsArrayBuffer() { throw new Error("FileReader.readAsArrayBuffer is not implemented in this polyfill"); }
+        readAsBinaryString() { throw new Error("FileReader.readAsBinaryString is not implemented in this polyfill"); }
+        readAsText() { throw new Error("FileReader.readAsText is not implemented in this polyfill"); }
+        abort() { throw new Error("FileReader.abort is not implemented in this polyfill"); }
+    };
+}
+`;
+
+function injectBanner(): import("vite").Plugin {
+    return {
+        name: "inject-banner",
+        generateBundle(_options, bundle) {
+            for (const chunk of Object.values(bundle)) {
+                if (chunk.type === "chunk" && chunk.fileName.startsWith("entrypoint")) {
+                    // Insert after the shebang line if present, otherwise at the top.
+                    if (chunk.code.startsWith("#!")) {
+                        const newline = chunk.code.indexOf("\n");
+                        chunk.code =
+                            chunk.code.slice(0, newline + 1) + fileReaderPolyfillBanner + chunk.code.slice(newline + 1);
+                    } else {
+                        chunk.code = fileReaderPolyfillBanner + chunk.code;
+                    }
+                }
+            }
+        },
+    };
+}
+
 export default defineConfig({
-    plugins: [svelte()],
+    plugins: [svelte(), injectBanner()],
     resolve: {
         alias: {
             "@lib/worker/bgWorker.ts": "../../lib/src/worker/bgWorker.mock.ts",

src/apps/webapp/bootstrap.ts

@@ -41,7 +41,7 @@ async function renderHistoryList(): Promise<VaultHistoryItem[]> {
 
     const [items, lastUsedId] = await Promise.all([historyStore.getVaultHistory(), historyStore.getLastUsedVaultId()]);
 
-    listEl.innerHTML = "";
+    listEl.replaceChildren();
     emptyEl.classList.toggle("is-hidden", items.length > 0);
 
     for (const item of items) {

src/common/reportTool.ts

@@ -0,0 +1,142 @@
+import { REMOTE_COUCHDB, REMOTE_MINIO } from "@lib/common/models/setting.const";
+import type { ObsidianLiveSyncSettings } from "@lib/common/models/setting.type";
+import { generateCredentialObject } from "@lib/replication/httplib";
+import { parseHeaderValues } from "@lib/common/utils";
+import { requestToCouchDBWithCredentials } from "./utils";
+import { LOG_LEVEL_VERBOSE, Logger } from "@lib/common/logger";
+import { DEFAULT_SETTINGS } from "@lib/common/models/setting.const.defaults";
+import { isCloudantURI } from "@lib/pouchdb/utils_couchdb";
+import { compatGlobal } from "@lib/common/coreEnvFunctions";
+import { manifestVersion, packageVersion } from "@lib/common/coreEnvVars";
+import type { LiveSyncBaseCore } from "@/LiveSyncBaseCore";
+function redactObject(obj: Record<string, any>, dotted: string, redactedValue = "REDACTED") {
+    const keys = dotted.split(".");
+    let current = obj;
+    for (let i = 0; i < keys.length - 1; i++) {
+        const key = keys[i];
+        if (!(key in current)) {
+            current[key] = {} as Record<string, any>;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        current = current[key];
+    }
+    const lastKey = keys[keys.length - 1];
+    if (lastKey in current) {
+        current[lastKey] = redactedValue;
+    }
+    return obj;
+}
+export async function generateReport(settings: ObsidianLiveSyncSettings, core: LiveSyncBaseCore) {
+    let responseConfig: Record<string, any> = {};
+    const REDACTED = "𝑅𝐸𝐷𝐴𝐶𝑇𝐸𝐷";
+    if (settings.remoteType == REMOTE_COUCHDB) {
+        try {
+            const credential = generateCredentialObject(settings);
+            const customHeaders = parseHeaderValues(settings.couchDB_CustomHeaders);
+            const r = await requestToCouchDBWithCredentials(
+                settings.couchDB_URI,
+                credential,
+                window.origin,
+                undefined,
+                undefined,
+                undefined,
+                customHeaders
+            );
+            responseConfig = r.json as Record<string, any>;
+            redactObject(responseConfig, "couch_httpd_auth.secret");
+            redactObject(responseConfig, "couch_httpd_auth.authentication_db");
+            redactObject(responseConfig, "couch_httpd_auth.authentication_redirect");
+            redactObject(responseConfig, "couchdb.uuid");
+            redactObject(responseConfig, "admins");
+            redactObject(responseConfig, "users");
+            redactObject(responseConfig, "chttpd_auth.secret");
+            delete responseConfig["jwt_keys"];
+        } catch (ex) {
+            Logger(ex, LOG_LEVEL_VERBOSE);
+            responseConfig = {
+                error: "Requesting information from the remote CouchDB has failed. If you are using IBM Cloudant, this is normal behaviour.",
+            };
+        }
+    } else if (settings.remoteType == REMOTE_MINIO) {
+        responseConfig = { error: "Object Storage Synchronisation" };
+        //
+    }
+    const defaultKeys = Object.keys(DEFAULT_SETTINGS) as (keyof ObsidianLiveSyncSettings)[];
+    const pluginConfig = JSON.parse(JSON.stringify(settings)) as ObsidianLiveSyncSettings;
+    const pluginKeys = Object.keys(pluginConfig);
+    for (const key of pluginKeys) {
+        if (defaultKeys.includes(key as keyof ObsidianLiveSyncSettings)) continue;
+        delete pluginConfig[key as keyof ObsidianLiveSyncSettings];
+    }
+
+    pluginConfig.couchDB_DBNAME = REDACTED;
+    pluginConfig.couchDB_PASSWORD = REDACTED;
+    const scheme = pluginConfig.couchDB_URI.startsWith("http:")
+        ? "(HTTP)"
+        : pluginConfig.couchDB_URI.startsWith("https:")
+          ? "(HTTPS)"
+          : "";
+    pluginConfig.couchDB_URI = isCloudantURI(pluginConfig.couchDB_URI) ? "cloudant" : `self-hosted${scheme}`;
+    pluginConfig.couchDB_USER = REDACTED;
+    pluginConfig.passphrase = REDACTED;
+    pluginConfig.encryptedPassphrase = REDACTED;
+    pluginConfig.encryptedCouchDBConnection = REDACTED;
+    pluginConfig.accessKey = REDACTED;
+    pluginConfig.secretKey = REDACTED;
+    const redact = (source: string) => `${REDACTED}(${source.length} letters)`;
+    const toSchemeOnly = (uri: string) => {
+        try {
+            return `${new URL(uri).protocol}//`;
+        } catch {
+            const matched = uri.match(/^[A-Za-z][A-Za-z0-9+.-]*:\/\//);
+            return matched?.[0] ?? REDACTED;
+        }
+    };
+    pluginConfig.remoteConfigurations = Object.fromEntries(
+        Object.entries(pluginConfig.remoteConfigurations || {}).map(([id, config]) => [
+            id,
+            {
+                ...config,
+                uri: toSchemeOnly(config.uri),
+            },
+        ])
+    );
+    pluginConfig.region = redact(pluginConfig.region);
+    pluginConfig.bucket = redact(pluginConfig.bucket);
+    pluginConfig.pluginSyncExtendedSetting = {};
+    pluginConfig.P2P_AppID = redact(pluginConfig.P2P_AppID);
+    pluginConfig.P2P_passphrase = redact(pluginConfig.P2P_passphrase);
+    pluginConfig.P2P_roomID = redact(pluginConfig.P2P_roomID);
+    pluginConfig.P2P_relays = redact(pluginConfig.P2P_relays);
+    pluginConfig.jwtKey = redact(pluginConfig.jwtKey);
+    pluginConfig.jwtSub = redact(pluginConfig.jwtSub);
+    pluginConfig.jwtKid = redact(pluginConfig.jwtKid);
+    pluginConfig.bucketCustomHeaders = redact(pluginConfig.bucketCustomHeaders);
+    pluginConfig.couchDB_CustomHeaders = redact(pluginConfig.couchDB_CustomHeaders);
+    pluginConfig.P2P_turnCredential = redact(pluginConfig.P2P_turnCredential);
+    pluginConfig.P2P_turnUsername = redact(pluginConfig.P2P_turnUsername);
+    pluginConfig.P2P_turnServers = `(${pluginConfig.P2P_turnServers.split(",").length} servers configured)`;
+    const endpoint = pluginConfig.endpoint;
+    if (endpoint == "") {
+        pluginConfig.endpoint = "Not configured or AWS";
+    } else {
+        const endpointScheme = pluginConfig.endpoint.startsWith("http:")
+            ? "(HTTP)"
+            : pluginConfig.endpoint.startsWith("https:")
+              ? "(HTTPS)"
+              : "";
+        pluginConfig.endpoint = `${endpoint.indexOf(".r2.cloudflarestorage.") !== -1 ? "R2" : "self-hosted?"}(${endpointScheme})`;
+    }
+    const obsidianInfo = {
+        navigator: compatGlobal.navigator.userAgent,
+        fileSystem: core.services.vault.isStorageInsensitive() ? "insensitive" : "sensitive",
+    };
+    const result = {
+        obsidianInfo,
+        responseConfig,
+        pluginConfig,
+        manifestVersion,
+        packageVersion,
+    };
+    return result;
+}

src/common/utils.ts

@@ -128,7 +128,7 @@ export const _requestToCouchDBFetch = async (
     username: string,
     password: string,
     path?: string,
-    body?: string | any,
+    body?: any,
     method?: string
 ) => {
     const utf8str = String.fromCharCode.apply(null, [...writeString(`${username}:${password}`)]);
@@ -146,7 +146,7 @@ export const _requestToCouchDBFetch = async (
         contentType: "application/json",
         body: JSON.stringify(body),
     };
-    return await fetch(uri, requestParam);
+    return await _fetch(uri, requestParam);
 };
 
 export const _requestToCouchDB = async (
@@ -214,6 +214,7 @@ import { BASE_IS_NEW, EVEN, TARGET_IS_NEW } from "@lib/common/models/shared.cons
 export { BASE_IS_NEW, EVEN, TARGET_IS_NEW };
 // Why 2000? : ZIP FILE Does not have enough resolution.
 import { compareMTime } from "@lib/common/utils.ts";
+import { _fetch } from "@/lib/src/common/coreEnvFunctions.ts";
 export { compareMTime };
 function getKey(file: AnyEntry | string | UXFileInfoStub) {
     const key = typeof file == "string" ? file : stripAllPrefixes(file.path);

src/features/ConfigSync/CmdConfigSync.ts

@@ -68,9 +68,10 @@ import { ConflictResolveModal } from "../../modules/features/InteractiveConflict
 import { Semaphore } from "octagonal-wheels/concurrency/semaphore";
 import { EVENT_REQUEST_OPEN_PLUGIN_SYNC_DIALOG, eventHub } from "../../common/events.ts";
 import { PluginDialogModal } from "./PluginDialogModal.ts";
-import { $msg } from "src/lib/src/common/i18n.ts";
+import { $msg } from "@/lib/src/common/i18n.ts";
 import type { InjectableServiceHub } from "../../lib/src/services/InjectableServices.ts";
 import type { LiveSyncCore } from "../../main.ts";
+import { LiveSyncError } from "@lib/common/LSError.ts";
 
 const d = "\u200b";
 const d2 = "\n";
@@ -564,7 +565,7 @@ export class ConfigSync extends LiveSyncCommands {
                 ...data,
                 documentPath: this.getPath(wx),
                 files: xFiles,
-            } as PluginDataExDisplay;
+            } satisfies PluginDataExDisplay;
         }
         return false;
     }
@@ -1069,10 +1070,10 @@ export class ConfigSync extends LiveSyncCommands {
         }
         const baseDir = this.configDir;
         try {
-            if (!data.documentPath) throw "InternalError: Document path not exist";
+            if (!data.documentPath) throw new LiveSyncError("InternalError: Document path not exist");
             const dx = await this.localDatabase.getDBEntry(data.documentPath);
             if (dx == false) {
-                throw "Not found on database";
+                throw new LiveSyncError("Not found on database");
             }
             const loadedData = deserialize(getDocDataAsArray(dx.data), {}) as PluginDataEx;
             for (const f of loadedData.files) {
@@ -1317,7 +1318,7 @@ export class ConfigSync extends LiveSyncCommands {
                     }
                     const docXDoc = await this.localDatabase.getDBEntryFromMeta(old, false, false);
                     if (docXDoc == false) {
-                        throw "Could not load the document";
+                        throw new LiveSyncError("Could not load the document");
                     }
                     const dataSrc = getDocData(docXDoc.data);
                     const dataStart = dataSrc.indexOf(DUMMY_END);

src/features/HiddenFileSync/CmdHiddenFileSync.ts

@@ -50,6 +50,7 @@ import { hiddenFilesEventCount, hiddenFilesProcessingCount } from "../../lib/src
 import { EVENT_SETTING_SAVED, eventHub } from "../../common/events.ts";
 import { Semaphore } from "octagonal-wheels/concurrency/semaphore";
 import type { LiveSyncCore } from "../../main.ts";
+import { tryGetFilePath } from "@lib/common/utils.doc.ts";
 type SyncDirection = "push" | "pull" | "safe" | "pullForce" | "pushForce";
 
 declare global {
@@ -317,7 +318,7 @@ export class HiddenFileSync extends LiveSyncCommands {
         this._fileInfoLastProcessed.set(file, key);
     }
 
-    async updateLastProcessedAsActualFile(file: FilePath, stat?: UXStat | null | undefined) {
+    async updateLastProcessedAsActualFile(file: FilePath, stat?: UXStat | null) {
         if (!stat) stat = await this.core.storageAccess.statHidden(file);
         this._fileInfoLastProcessed.set(file, this.statToKey(stat));
     }
@@ -411,10 +412,7 @@ export class HiddenFileSync extends LiveSyncCommands {
         }
     }
 
-    async updateLastProcessedAsActualDatabase(
-        file: FilePath,
-        doc?: MetaEntry | LoadedEntry | null | undefined | false
-    ) {
+    async updateLastProcessedAsActualDatabase(file: FilePath, doc?: MetaEntry | LoadedEntry | null | false) {
         const dbPath = addPrefix(file, ICHeader);
         if (!doc) doc = await this.localDatabase.getDBEntryMeta(dbPath);
         if (!doc) return;
@@ -1050,7 +1048,7 @@ Offline Changed files: ${processFiles.length}`;
                 }
                 notifyProgress();
             } catch (ex) {
-                this._log(`Failed to process storage change file:${file}`, logLevel);
+                this._log(`Failed to process storage change file:${tryGetFilePath(file)}`, logLevel);
                 this._log(ex, LOG_LEVEL_VERBOSE);
             }
         });
@@ -1162,7 +1160,7 @@ Offline Changed files: ${files.length}`;
                 await this.trackDatabaseFileModification(path, "[Scanning]", true, onlyNew, file);
                 notifyProgress();
             } catch (ex) {
-                this._log(`Failed to process database changes:${file}`);
+                this._log(`Failed to process database changes:${tryGetFilePath(file)}`);
                 this._log(ex, LOG_LEVEL_VERBOSE);
             }
             return;
@@ -1500,7 +1498,7 @@ Offline Changed files: ${files.length}`;
     }
 
     async storeInternalFileToDatabase(file: InternalFileInfo | UXFileInfo, forceWrite = false) {
-        const storeFilePath = stripAllPrefixes(file.path as FilePath);
+        const storeFilePath = stripAllPrefixes(file.path);
         const storageFilePath = file.path;
         if (await this.services.vault.isIgnoredByIgnoreFile(storageFilePath)) {
             return undefined;

src/features/LocalDatabaseMainte/CmdLocalDatabaseMainte.ts

@@ -16,9 +16,8 @@ import { serialized } from "octagonal-wheels/concurrency/lock_v2";
 import { arrayToChunkedArray } from "octagonal-wheels/collection";
 import { EVENT_ANALYSE_DB_USAGE, EVENT_REQUEST_PERFORM_GC_V3, eventHub } from "@/common/events";
 import type { LiveSyncCouchDBReplicator } from "@/lib/src/replication/couchdb/LiveSyncReplicator";
-import { delay, parseHeaderValues } from "@/lib/src/common/utils";
-import { generateCredentialObject } from "@/lib/src/replication/httplib";
-import { _requestToCouchDB } from "@/common/utils";
+import { delay } from "@/lib/src/common/utils";
+// import { _requestToCouchDB } from "@/common/utils";
 const DB_KEY_SEQ = "gc-seq";
 const DB_KEY_CHUNK_SET = "chunk-set";
 const DB_KEY_DOC_USAGE_MAP = "doc-usage-map";
@@ -391,7 +390,7 @@ Note: **Make sure to synchronise all devices before deletion.**
                             .map((revInfo) => db.get(doc._id, { rev: revInfo.rev }))
                     ).then((docs) => docs.filter((doc) => doc));
                     for (const oldDoc of oldDocs) {
-                        await processDoc(oldDoc as EntryDoc, false);
+                        await processDoc(oldDoc, false);
                     }
                 }
             } catch (ex) {
@@ -533,7 +532,7 @@ Success: ${successCount}, Errored: ${errored}`;
         const docMap = new Map<DocumentID, Set<DocumentInfo>>();
         const info = await db.info();
         // Total number of revisions to process (approximate)
-        const maxSeq = new Number(info.update_seq);
+        const maxSeq = Number.parseInt(`${info.update_seq ?? 0}`, 10);
         let processed = 0;
         let read = 0;
         let errored = 0;
@@ -560,7 +559,7 @@ Success: ${successCount}, Errored: ${errored}`;
                         });
                         docMap.set(id, set);
                     } else if (doc.type === EntryTypes.CHUNK) {
-                        const id = doc._id as DocumentID;
+                        const id = doc._id;
                         if (chunkMap.has(id)) {
                             return;
                         }
@@ -759,68 +758,68 @@ Success: ${successCount}, Errored: ${errored}`;
         }
     }
 
-    /**
-     * Compact the database by temporarily setting the revision limit to 1.
-     * @returns
-     */
-    async compactDatabaseWithRevLimit() {
-        // Temporarily set revs_limit to 1, perform compaction, and restore the original revs_limit.
-        // Very dangerous operation, so now suppressed.
-        return false;
-        const replicator = this.core.replicator as LiveSyncCouchDBReplicator;
-        const remote = await replicator.connectRemoteCouchDBWithSetting(this.settings, false, false, true);
-        if (!remote) {
-            this._notice("Failed to connect to remote for compaction.");
-            return;
-        }
-        if (typeof remote == "string") {
-            this._notice(`Failed to connect to remote for compaction. ${remote}`);
-            return;
-        }
-        const customHeaders = parseHeaderValues(this.settings.couchDB_CustomHeaders);
-        const credential = generateCredentialObject(this.settings);
-        const request = async (path: string, method: string = "GET", body: any = undefined) => {
-            const req = await _requestToCouchDB(
-                this.settings.couchDB_URI.replace(/\/+$/, "") +
-                    (this.settings.couchDB_DBNAME ? `/${this.settings.couchDB_DBNAME}` : ""),
-                credential,
-                window.origin,
-                path,
-                body,
-                method,
-                customHeaders
-            );
-            return req;
-        };
-        let revsLimit = "";
-        const req = await request(`_revs_limit`, "GET");
-        if (req.status == 200) {
-            revsLimit = req.text.trim();
-            this._info(`Remote database _revs_limit: ${revsLimit}`);
-        } else {
-            this._notice(`Failed to get remote database _revs_limit. Status: ${req.status}`);
-            return;
-        }
-        const req2 = await request(`_revs_limit`, "PUT", 1);
-        if (req2.status == 200) {
-            this._info(`Set remote database _revs_limit to 1 for compaction.`);
-        }
-        try {
-            await this.compactDatabase();
-        } finally {
-            // Restore revs_limit
-            if (revsLimit) {
-                const req3 = await request(`_revs_limit`, "PUT", parseInt(revsLimit));
-                if (req3.status == 200) {
-                    this._info(`Restored remote database _revs_limit to ${revsLimit}.`);
-                } else {
-                    this._notice(
-                        `Failed to restore remote database _revs_limit. Status: ${req3.status} / ${req3.text}`
-                    );
-                }
-            }
-        }
-    }
+    // /**
+    //  * Compact the database by temporarily setting the revision limit to 1.
+    //  * @returns
+    //  */
+    // async compactDatabaseWithRevLimit() {
+    //     // Temporarily set revs_limit to 1, perform compaction, and restore the original revs_limit.
+    //     // Very dangerous operation, so now suppressed.
+    //     return Promise.resolve(false);
+    //     const replicator = this.core.replicator as LiveSyncCouchDBReplicator;
+    //     const remote = await replicator.connectRemoteCouchDBWithSetting(this.settings, false, false, true);
+    //     if (!remote) {
+    //         this._notice("Failed to connect to remote for compaction.");
+    //         return;
+    //     }
+    //     if (typeof remote == "string") {
+    //         this._notice(`Failed to connect to remote for compaction. ${remote}`);
+    //         return;
+    //     }
+    //     const customHeaders = parseHeaderValues(this.settings.couchDB_CustomHeaders);
+    //     const credential = generateCredentialObject(this.settings);
+    //     const request = async (path: string, method: string = "GET", body: any = undefined) => {
+    //         const req = await _requestToCouchDB(
+    //             this.settings.couchDB_URI.replace(/\/+$/, "") +
+    //             (this.settings.couchDB_DBNAME ? `/${this.settings.couchDB_DBNAME}` : ""),
+    //             credential,
+    //             window.origin,
+    //             path,
+    //             body,
+    //             method,
+    //             customHeaders
+    //         );
+    //         return req;
+    //     };
+    //     let revsLimit = "";
+    //     const req = await request(`_revs_limit`, "GET");
+    //     if (req.status == 200) {
+    //         revsLimit = req.text.trim();
+    //         this._info(`Remote database _revs_limit: ${revsLimit}`);
+    //     } else {
+    //         this._notice(`Failed to get remote database _revs_limit. Status: ${req.status}`);
+    //         return;
+    //     }
+    //     const req2 = await request(`_revs_limit`, "PUT", 1);
+    //     if (req2.status == 200) {
+    //         this._info(`Set remote database _revs_limit to 1 for compaction.`);
+    //     }
+    //     try {
+    //         await this.compactDatabase();
+    //     } finally {
+    //         // Restore revs_limit
+    //         if (revsLimit) {
+    //             const req3 = await request(`_revs_limit`, "PUT", parseInt(revsLimit));
+    //             if (req3.status == 200) {
+    //                 this._info(`Restored remote database _revs_limit to ${revsLimit}.`);
+    //             } else {
+    //                 this._notice(
+    //                     `Failed to restore remote database _revs_limit. Status: ${req3.status} / ${req3.text}`
+    //                 );
+    //             }
+    //         }
+    //     }
+    // }
     async gcv3() {
         if (!this.isAvailable()) return;
         const replicator = this.core.replicator as LiveSyncCouchDBReplicator;
@@ -929,7 +928,7 @@ This may indicate that some devices have not completed synchronisation, which co
                     usedChunks.add(chunkId);
                 }
             } else if (doc.type === EntryTypes.CHUNK) {
-                allChunks.set(doc._id as DocumentID, doc._rev);
+                allChunks.set(doc._id, doc._rev);
             }
         }
         this._notice(

src/features/P2PSync/P2PReplicator/P2POpenReplicationModal.ts

@@ -0,0 +1,80 @@
+import { App, Modal } from "@/deps.ts";
+import P2POpenReplicationPane from "./P2POpenReplicationPane.svelte";
+import { mount, unmount } from "svelte";
+import type { LiveSyncTrysteroReplicator } from "@/lib/src/replication/trystero/LiveSyncTrysteroReplicator";
+
+export type P2POpenReplicationModalCallback = {
+    onSync: (peerId: string) => Promise<void>;
+    onSyncAndClose: (peerId: string) => Promise<void>;
+};
+
+export class P2POpenReplicationModal extends Modal {
+    liveSyncReplicator: LiveSyncTrysteroReplicator;
+    callback?: P2POpenReplicationModalCallback;
+    component?: ReturnType<typeof mount>;
+    showResult: boolean;
+    title: string;
+    onClosed?: () => void;
+    rebuildMode: boolean;
+
+    constructor(
+        app: App,
+        liveSyncReplicator: LiveSyncTrysteroReplicator,
+        callback?: P2POpenReplicationModalCallback,
+        showResult: boolean = false,
+        title: string = "P2P Replication",
+        onClosed?: () => void,
+        rebuildMode: boolean = false
+    ) {
+        super(app);
+        this.liveSyncReplicator = liveSyncReplicator;
+        this.callback = callback;
+        this.showResult = showResult;
+        this.title = title;
+        this.onClosed = onClosed;
+        this.rebuildMode = rebuildMode;
+    }
+
+    async onSync(peerId: string) {
+        if (this.callback?.onSync) {
+            await this.callback.onSync(peerId);
+        }
+    }
+
+    async onSyncAndClose(peerId: string) {
+        if (this.callback?.onSyncAndClose) {
+            await this.callback.onSyncAndClose(peerId);
+        }
+        this.close();
+    }
+
+    override onOpen() {
+        const { contentEl } = this;
+        this.titleEl.setText(this.title);
+        contentEl.empty();
+
+        if (this.component === undefined) {
+            this.component = mount(P2POpenReplicationPane, {
+                target: contentEl,
+                props: {
+                    liveSyncReplicator: this.liveSyncReplicator,
+                    onSync: (peerId: string) => this.onSync(peerId),
+                    onSyncAndClose: (peerId: string) => this.onSyncAndClose(peerId),
+                    onClose: () => this.close(),
+                    showResult: this.showResult,
+                    rebuildMode: this.rebuildMode,
+                },
+            });
+        }
+    }
+
+    override onClose() {
+        const { contentEl } = this;
+        contentEl.empty();
+        if (this.component !== undefined) {
+            void unmount(this.component);
+            this.component = undefined;
+        }
+        this.onClosed?.();
+    }
+}

src/features/P2PSync/P2PReplicator/P2POpenReplicationPane.svelte

@@ -0,0 +1,313 @@
+<script lang="ts">
+    import { onMount } from "svelte";
+    import { eventHub } from "@/common/events";
+    import {
+        EVENT_SERVER_STATUS,
+        EVENT_REQUEST_STATUS,
+        type P2PServerInfo,
+    } from "@lib/replication/trystero/TrysteroReplicatorP2PServer";
+    // import type { TrysteroReplicator } from "@lib/replication/trystero/TrysteroReplicator";
+    import { LOG_LEVEL_NOTICE, LOG_LEVEL_INFO } from "@lib/common/types";
+    import { Logger } from "@lib/common/logger";
+    import type { LiveSyncTrysteroReplicator } from "@/lib/src/replication/trystero/LiveSyncTrysteroReplicator";
+    import { delay, fireAndForget } from "octagonal-wheels/promises";
+    import P2PServerStatusCard from "./P2PServerStatusCard.svelte";
+
+    interface Props {
+        liveSyncReplicator: LiveSyncTrysteroReplicator;
+        onSync: (_peerId: string) => Promise<void>;
+        onSyncAndClose: (_peerId: string) => Promise<void>;
+        onClose: () => void;
+        showResult: boolean;
+        rebuildMode?: boolean;
+    }
+
+    let { onSync, onSyncAndClose, onClose, showResult, liveSyncReplicator, rebuildMode = false }: Props = $props();
+
+    let serverInfo = $state<P2PServerInfo | undefined>(undefined);
+    let syncingPeerId = $state<string | null>(null);
+
+    const logLevel = showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO;
+    async function requestServerStatus() {
+        await liveSyncReplicator.requestStatus();
+        eventHub.emitEvent(EVENT_REQUEST_STATUS);
+    }
+    onMount(() => {
+        // ServerStatus
+        const unsubscribe = eventHub.onEvent(EVENT_SERVER_STATUS, (status) => {
+            serverInfo = status;
+        });
+        fireAndForget(async () => {
+            await delay(100);
+            await requestServerStatus();
+        });
+        return unsubscribe;
+    });
+
+    async function handleSync(peerId: string) {
+        try {
+            syncingPeerId = peerId;
+            Logger(`Starting sync with ${peerId}`, logLevel);
+            await onSync(peerId);
+            Logger(`Sync completed with ${peerId}`, logLevel);
+        } catch (e) {
+            Logger(`Error during sync: ${e instanceof Error ? e.message : String(e)}`, logLevel);
+        } finally {
+            syncingPeerId = null;
+        }
+    }
+    async function handleSyncThenClose(peerId: string) {
+        try {
+            syncingPeerId = peerId;
+            Logger(`Starting sync with ${peerId}`, logLevel);
+            await onSyncAndClose(peerId);
+            Logger(`Sync completed with ${peerId}`, logLevel);
+        } catch (e) {
+            Logger(`Error during sync: ${e instanceof Error ? e.message : String(e)}`, logLevel);
+        } finally {
+            syncingPeerId = null;
+        }
+    }
+
+    async function handleSyncAndClose(peerId: string) {
+        fireAndForget(async () => {
+            try {
+                Logger(`Starting sync with ${peerId}`, logLevel);
+                await onSync(peerId);
+                Logger(`Sync completed with ${peerId}`, logLevel);
+            } catch (e) {
+                Logger(`Error during sync: ${e instanceof Error ? e.message : String(e)}`, logLevel);
+            }
+        });
+        onClose();
+    }
+    async function disconnect() {
+        try {
+            await liveSyncReplicator.close();
+            Logger("Signalling connection closed.", logLevel);
+        } catch (e) {
+            Logger(`Failed to close signalling connection: ${e instanceof Error ? e.message : String(e)}`, logLevel);
+        }
+    }
+    async function onCloseAndDisconnect() {
+        await disconnect();
+        onClose();
+    }
+
+    function getAcceptanceStatus(peer: P2PServerInfo["knownAdvertisements"][number]) {
+        if (peer.isTemporaryAccepted === true) return "ACCEPTED (in session)";
+        if (peer.isAccepted === true) return "ACCEPTED";
+        if (peer.isTemporaryAccepted === false) return "DENIED (in session)";
+        if (peer.isAccepted === false) return "DENIED";
+        return "NEW";
+    }
+
+    function getAcceptanceStatusClass(peer: P2PServerInfo["knownAdvertisements"][number]) {
+        if (peer.isTemporaryAccepted === true || peer.isAccepted === true) return "accepted";
+        if (peer.isTemporaryAccepted === false || peer.isAccepted === false) return "denied";
+        return "unknown";
+    }
+</script>
+
+<div class="p2p-container">
+    <P2PServerStatusCard {liveSyncReplicator} showBroadcastToggle={false} />
+
+    <div class="peers-section">
+        <h3>Available Peers</h3>
+        {#if serverInfo && serverInfo.knownAdvertisements.length > 0}
+            <div class="peers-list">
+                {#each serverInfo.knownAdvertisements as peer (peer.peerId)}
+                    <div class="peer-item">
+                        <div class="peer-info">
+                            <div class="peer-name">{peer.name}</div>
+                            <div class="peer-meta">
+                                <span class="badge">{peer.platform}</span>
+                                <span class="peer-id-mini" title={peer.peerId}>
+                                    {peer.peerId.slice(0, 8)}
+                                </span>
+                                <span class="badge status-chip {getAcceptanceStatusClass(peer)}">
+                                    {getAcceptanceStatus(peer)}
+                                </span>
+                            </div>
+                        </div>
+                        <div class="peer-actions">
+                            {#if !rebuildMode}
+                                <button
+                                    class="btn btn-primary"
+                                    disabled={syncingPeerId !== null}
+                                    onclick={() => handleSync(peer.peerId)}
+                                >
+                                    {syncingPeerId === peer.peerId ? "Syncing..." : "Sync"}
+                                </button>
+                                <button
+                                    class="btn {rebuildMode ? 'btn-primary' : 'btn-secondary'}"
+                                    disabled={syncingPeerId !== null}
+                                    onclick={() => handleSyncAndClose(peer.peerId)}
+                                >
+                                    {syncingPeerId === peer.peerId ? "Syncing..." : "Start Sync & Close"}
+                                </button>
+                            {:else}
+                                <button
+                                    class="btn {rebuildMode ? 'btn-primary' : 'btn-secondary'}"
+                                    disabled={syncingPeerId !== null}
+                                    onclick={() => handleSyncThenClose(peer.peerId)}
+                                >
+                                    {syncingPeerId === peer.peerId ? "Syncing..." : "Sync"}
+                                </button>
+                            {/if}
+                        </div>
+                    </div>
+                {/each}
+            </div>
+        {:else if serverInfo}
+            <p class="no-peers">No devices available. Waiting for other devices to connect...</p>
+        {/if}
+    </div>
+
+    <div class="footer">
+        {#if rebuildMode}
+            <button class="btn btn-cancel" onclick={onClose} disabled={syncingPeerId !== null}>Skip and close</button>
+        {:else}
+            <button class="btn btn-cancel" onclick={onClose}>Close</button>
+            <button class="btn btn-cancel" onclick={onCloseAndDisconnect}>Close & Disconnect</button>
+        {/if}
+    </div>
+</div>
+
+<style>
+    .p2p-container {
+        display: flex;
+        flex-direction: column;
+        gap: 1rem;
+        padding: 1rem;
+        max-height: 70vh;
+        overflow-y: auto;
+    }
+
+    .peers-section {
+        border: 1px solid var(--divider-color);
+        border-radius: 0.5rem;
+        padding: 1rem;
+    }
+
+    h3 {
+        margin: 0 0 0.75rem 0;
+        font-weight: 600;
+        font-size: 1rem;
+    }
+
+    .peers-list {
+        display: flex;
+        flex-direction: column;
+        gap: 0.5rem;
+    }
+
+    .peer-item {
+        display: flex;
+        justify-content: space-between;
+        flex-wrap: wrap;
+        align-items: center;
+        padding: 0.75rem;
+        background-color: var(--background-secondary);
+        border: 1px solid var(--divider-color);
+        border-radius: 0.4rem;
+    }
+
+    .peer-info {
+        flex: 1;
+    }
+
+    .peer-name {
+        font-weight: 600;
+        margin-bottom: 0.25rem;
+    }
+
+    .peer-meta {
+        display: flex;
+        gap: 0.5rem;
+        font-size: 0.8rem;
+    }
+
+    .badge {
+        background-color: var(--background-tertiary);
+        padding: 0.1rem 0.4rem;
+        border-radius: 0.25rem;
+    }
+
+    .status-chip {
+        font-weight: 600;
+    }
+
+    .status-chip.accepted {
+        background-color: var(--background-modifier-success);
+        color: var(--text-normal);
+    }
+
+    .status-chip.denied {
+        background-color: var(--background-modifier-error);
+        color: var(--text-normal);
+    }
+
+    .status-chip.unknown {
+        background-color: var(--background-modifier-border);
+        color: var(--text-muted);
+    }
+
+    .peer-id-mini {
+        font-family: monospace;
+        color: var(--text-muted);
+    }
+
+    .peer-actions {
+        flex-wrap: wrap;
+        display: flex;
+        gap: 0.5rem;
+    }
+
+    .btn {
+        padding: 0.4rem 0.8rem;
+        border: 1px solid var(--divider-color);
+        border-radius: 0.3rem;
+        background-color: var(--interactive-normal);
+        color: var(--text-normal);
+        cursor: pointer;
+        font-size: 0.8rem;
+        font-weight: 500;
+        transition: background-color 0.2s;
+    }
+
+    .btn:hover:not(:disabled) {
+        background-color: var(--interactive-hover);
+    }
+
+    .btn:disabled {
+        opacity: 0.6;
+        cursor: not-allowed;
+    }
+
+    .btn-primary {
+        background-color: var(--interactive-accent);
+        color: var(--text-on-accent);
+    }
+
+    .btn-secondary {
+        background-color: var(--background-tertiary);
+    }
+
+    .btn-cancel {
+        width: 100%;
+        margin-top: 0.5rem;
+    }
+
+    .no-peers {
+        text-align: center;
+        color: var(--text-muted);
+        font-size: 0.9rem;
+        padding: 1rem;
+    }
+
+    .footer {
+        border-top: 1px solid var(--divider-color);
+        padding-top: 0.75rem;
+    }
+</style>

src/features/P2PSync/P2PReplicator/P2PReplicationUI.ts

@@ -0,0 +1,131 @@
+import { App } from "@/deps.ts";
+import { Logger } from "@lib/common/logger";
+import { LOG_LEVEL_NOTICE, LOG_LEVEL_INFO } from "@lib/common/types";
+import type { LiveSyncTrysteroReplicator } from "@lib/replication/trystero/LiveSyncTrysteroReplicator";
+import { P2POpenReplicationModal } from "./P2POpenReplicationModal";
+
+/**
+ * Creates an openReplicationUI factory for Obsidian environments.
+ * Returns a per-replicator closure that opens the P2P Replication modal
+ * and performs bidirectional sync (pull then push on success).
+ *
+ * Usage:
+ *   const factory = createOpenReplicationUI(app);
+ *   useP2PReplicatorFeature(core, factory);
+ */
+export function createOpenReplicationUI(
+    app: App
+): (replicator: LiveSyncTrysteroReplicator) => (showResult: boolean) => Promise<boolean | void> {
+    return (replicator: LiveSyncTrysteroReplicator) =>
+        (showResult: boolean): Promise<boolean | void> => {
+            const logLevel = showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO;
+            return new Promise<boolean | void>((resolve) => {
+                const modal = new P2POpenReplicationModal(
+                    app,
+                    replicator,
+                    {
+                        onSync: async (peerId: string) => {
+                            try {
+                                // pull (replicateFrom) first; push only on success
+                                const pullResult = await replicator.replicateFrom(peerId, showResult);
+                                if (pullResult?.ok) {
+                                    const pushResult = await replicator.requestSynchroniseToPeer(peerId);
+                                    resolve(pushResult?.ok ?? true);
+                                } else {
+                                    resolve(false);
+                                }
+                            } catch (e) {
+                                Logger(
+                                    `Error in bidirectional sync with ${peerId}: ${e instanceof Error ? e.message : String(e)}`,
+                                    logLevel
+                                );
+                                resolve(false);
+                            }
+                        },
+                        onSyncAndClose: async (peerId: string) => {
+                            try {
+                                const pullResult = await replicator.replicateFrom(peerId, showResult);
+                                if (pullResult?.ok) {
+                                    const pushResult = await replicator.requestSynchroniseToPeer(peerId);
+                                    if (pushResult?.ok ?? true) {
+                                        await replicator.close();
+                                        resolve(true);
+                                    } else {
+                                        resolve(false);
+                                    }
+                                } else {
+                                    resolve(false);
+                                }
+                            } catch (e) {
+                                Logger(
+                                    `Error in bidirectional sync with ${peerId}: ${e instanceof Error ? e.message : String(e)}`,
+                                    logLevel
+                                );
+                                resolve(false);
+                            }
+                        },
+                    },
+                    showResult
+                );
+                modal.open();
+            });
+        };
+}
+
+/**
+ * Creates an openRebuildUI factory for Obsidian environments.
+ * Opens the P2P Replication modal in "rebuild" mode — one-way pull only,
+ * with setOnSetup / clearOnSetup bracketing the replicateFrom call.
+ *
+ * Usage:
+ *   const factory = createOpenRebuildUI(app);
+ *   useP2PReplicatorFeature(core, createOpenReplicationUI(app), factory);
+ */
+export function createOpenRebuildUI(
+    app: App
+): (replicator: LiveSyncTrysteroReplicator) => (showResult: boolean) => Promise<boolean | void> {
+    return (replicator: LiveSyncTrysteroReplicator) =>
+        (showResult: boolean): Promise<boolean | void> => {
+            const logLevel = showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO;
+            return new Promise<boolean | void>((resolve) => {
+                let resolved = false;
+                const safeResolve = (val: boolean) => {
+                    if (!resolved) {
+                        resolved = true;
+                        resolve(val);
+                    }
+                };
+
+                const doRebuild = async (peerId: string) => {
+                    replicator.setOnSetup();
+                    try {
+                        Logger(`Rebuilding from peer ${peerId}`, logLevel);
+                        const result = await replicator.replicateFrom(peerId, showResult);
+                        safeResolve(result?.ok ?? false);
+                    } catch (e) {
+                        Logger(
+                            `Error in rebuild from ${peerId}: ${e instanceof Error ? e.message : String(e)}`,
+                            logLevel
+                        );
+                        safeResolve(false);
+                    } finally {
+                        replicator.clearOnSetup();
+                    }
+                };
+
+                const modal = new P2POpenReplicationModal(
+                    app,
+                    replicator,
+                    {
+                        onSync: doRebuild,
+                        onSyncAndClose: doRebuild,
+                    },
+                    showResult,
+                    "P2P Rebuild",
+                    () => safeResolve(false),
+                    true
+                );
+                modal.open();
+            });
+        };
+}

src/features/P2PSync/P2PReplicator/P2PReplicatorPane.svelte

@@ -5,20 +5,21 @@
         AcceptedStatus,
         ConnectionStatus,
         type PeerStatus,
-    } from "../../../lib/src/replication/trystero/P2PReplicatorPaneCommon";
-    import type { LiveSyncTrysteroReplicator } from "../../../lib/src/replication/trystero/LiveSyncTrysteroReplicator";
+    } from "@lib/replication/trystero/P2PReplicatorPaneCommon";
+    import type { LiveSyncTrysteroReplicator } from "@lib/replication/trystero/LiveSyncTrysteroReplicator";
     import PeerStatusRow from "../P2PReplicator/PeerStatusRow.svelte";
-    import { EVENT_LAYOUT_READY, eventHub } from "../../../common/events";
+    import { EVENT_LAYOUT_READY, eventHub } from "@/common/events";
     import {
         type PeerInfo,
         type P2PServerInfo,
         EVENT_SERVER_STATUS,
         EVENT_REQUEST_STATUS,
         EVENT_P2P_REPLICATOR_STATUS,
-    } from "../../../lib/src/replication/trystero/TrysteroReplicatorP2PServer";
-    import { type P2PReplicatorStatus } from "../../../lib/src/replication/trystero/TrysteroReplicator";
-    import { $msg as _msg } from "../../../lib/src/common/i18n";
-    import { SETTING_KEY_P2P_DEVICE_NAME } from "../../../lib/src/common/types";
+    } from "@lib/replication/trystero/TrysteroReplicatorP2PServer";
+    import { type P2PReplicatorStatus } from "@lib/replication/trystero/TrysteroReplicator";
+    import { $msg as _msg } from "@lib/common/i18n";
+    import { SETTING_KEY_P2P_DEVICE_NAME } from "@lib/common/types";
+    import { generateP2PRoomId } from "@lib/common/utils";
     import type { LiveSyncBaseCore } from "@/LiveSyncBaseCore";
 
     interface Props {
@@ -148,6 +149,7 @@
         eventHub.emitEvent(EVENT_REQUEST_STATUS);
         return () => {
             r();
+            rx();
             r2();
             r3();
         };
@@ -216,18 +218,8 @@
     function useDefaultRelay() {
         eRelay = DEFAULT_SETTINGS.P2P_relays;
     }
-    function _generateRandom() {
-        return (Math.floor(Math.random() * 1000) + 1000).toString().substring(1);
-    }
-    function generateRandom(length: number) {
-        let buf = "";
-        while (buf.length < length) {
-            buf += "-" + _generateRandom();
-        }
-        return buf.substring(1, length);
-    }
     function chooseRandom() {
-        eRoomId = generateRandom(12) + "-" + Math.random().toString(36).substring(2, 5);
+        eRoomId = generateP2PRoomId();
     }
 
     async function openServer() {
@@ -251,7 +243,7 @@
                 setting?: boolean;
             };
             return initialDialogStatus;
-        } catch (e) {
+        } catch {
             return {};
         }
     };

src/features/P2PSync/P2PReplicator/P2PServerStatusCard.svelte

@@ -0,0 +1,310 @@
+<script lang="ts">
+    import { onMount } from "svelte";
+    import { eventHub } from "@/common/events";
+    import { delay, fireAndForget } from "octagonal-wheels/promises";
+    import type { P2PServerInfo } from "@lib/replication/trystero/TrysteroReplicatorP2PServer";
+    import {
+        EVENT_SERVER_STATUS,
+        EVENT_REQUEST_STATUS,
+        EVENT_P2P_REPLICATOR_STATUS,
+    } from "@lib/replication/trystero/TrysteroReplicatorP2PServer";
+    import { EVENT_SETTING_SAVED } from "@lib/events/coreEvents";
+    import type { LiveSyncTrysteroReplicator } from "@/lib/src/replication/trystero/LiveSyncTrysteroReplicator";
+    import type { P2PReplicatorStatus } from "@/lib/src/replication/trystero/TrysteroReplicator";
+    import { extractP2PRoomSuffix } from "@/lib/src/common/utils";
+    import type { LiveSyncBaseCore } from "@/LiveSyncBaseCore";
+
+    interface Props {
+        liveSyncReplicator: LiveSyncTrysteroReplicator;
+        showBroadcastToggle?: boolean;
+        core?: LiveSyncBaseCore;
+    }
+
+    let { liveSyncReplicator, showBroadcastToggle = true, core }: Props = $props();
+    let serverInfo = $state<P2PServerInfo | undefined>(undefined);
+    let replicatorStatus = $state<P2PReplicatorStatus | undefined>(undefined);
+    let roomSuffix = $state<string>(extractP2PRoomSuffix(core?.services.setting.currentSettings()?.P2P_roomID ?? ""));
+    let useDiagRTC = $state<boolean>(core?.services.setting.currentSettings()?.P2P_useDiagRTC ?? false);
+
+    async function requestServerStatus() {
+        await Promise.resolve(liveSyncReplicator.requestStatus());
+        eventHub.emitEvent(EVENT_REQUEST_STATUS);
+    }
+
+    async function onOpenConnection() {
+        await liveSyncReplicator.makeSureOpened();
+        await requestServerStatus();
+    }
+
+    async function onDisconnect() {
+        await liveSyncReplicator.close();
+        await requestServerStatus();
+    }
+
+    function toggleBroadcast() {
+        if (replicatorStatus?.isBroadcasting) {
+            liveSyncReplicator.disableBroadcastChanges();
+        } else {
+            liveSyncReplicator.enableBroadcastChanges();
+        }
+    }
+
+    async function toggleDiagRTC() {
+        if (!core) {
+            return;
+        }
+        const next = !useDiagRTC;
+        await core.services.setting.updateSettings((settings) => {
+            settings.P2P_useDiagRTC = next;
+            return settings;
+        }, true);
+        useDiagRTC = next;
+    }
+
+    onMount(() => {
+        const unsubscribe = eventHub.onEvent(EVENT_SERVER_STATUS, (status) => {
+            serverInfo = status;
+            roomSuffix = extractP2PRoomSuffix(status?.roomId ?? "");
+        });
+        const unsubscribeStatus = eventHub.onEvent(EVENT_P2P_REPLICATOR_STATUS, (status) => {
+            replicatorStatus = status;
+        });
+        const unsubscribeSettings = eventHub.onEvent(EVENT_SETTING_SAVED, (settings) => {
+            roomSuffix = extractP2PRoomSuffix(settings?.P2P_roomID ?? "");
+            useDiagRTC = settings?.P2P_useDiagRTC ?? false;
+        });
+
+        fireAndForget(async () => {
+            await delay(100);
+            await requestServerStatus();
+        });
+
+        return () => {
+            unsubscribe();
+            unsubscribeStatus();
+            unsubscribeSettings();
+        };
+    });
+
+    const isConnected = $derived.by(() => serverInfo?.isConnected);
+    const isBroadcasting = $derived.by(() => replicatorStatus?.isBroadcasting ?? false);
+</script>
+
+<div class="server-status">
+    <h3>Signalling Status</h3>
+
+    <div class="status-item">
+        <span>Connection:</span>
+        <span class="status-value {isConnected ? 'connected' : 'disconnected'}">
+            {isConnected ? "🟢 Connected" : "🔴 Disconnected"}
+        </span>
+    </div>
+
+    <div class="status-item status-action">
+        {#if !isConnected}
+            <button onclick={onOpenConnection}>Open connection</button>
+        {:else}
+            <button onclick={onDisconnect}>Close connection</button>
+        {/if}
+    </div>
+
+    {#if serverInfo}
+        <div class="status-item">
+            <span>Room ID suffix:</span>
+            <span class="room-suffix-display" title={roomSuffix || "Not configured"}>
+                {roomSuffix || "-"}
+            </span>
+        </div>
+
+        <div class="status-item">
+            <span>Peer ID:</span>
+            <span class="peer-id-display" title={serverInfo.serverPeerId}>
+                {serverInfo.serverPeerId.slice(0, 12)}...
+            </span>
+        </div>
+
+        <div class="status-item">
+            <span>Devices:</span>
+            <span>{serverInfo.knownAdvertisements.length}</span>
+        </div>
+    {/if}
+
+    {#if showBroadcastToggle}
+    <div class="status-item status-action broadcast-row">
+        <!-- Live-push to peers: stream this device's changes to connected peers for LiveSync -->
+        <label class="broadcast-label" for="broadcast-toggle">
+            Live-push to peers
+        </label>
+        <button
+            id="broadcast-toggle"
+            class="broadcast-button {isBroadcasting ? 'is-on' : 'is-off'}"
+            onclick={toggleBroadcast}
+            title={isBroadcasting ? 'Pushing changes to peers — click to stop' : 'Start pushing changes to peers'}
+        >
+            {isBroadcasting ? '📡 On' : '📡 Off'}
+        </button>
+    </div>
+    {/if}
+
+    {#if core}
+    <div class="status-item status-action diag-toggle-row">
+        <label class="broadcast-label" for="diag-toggle">
+            🕵️ Diag
+        </label>
+        <button
+            id="diag-toggle"
+            class="broadcast-button {useDiagRTC ? 'is-on' : 'is-off'}"
+            onclick={toggleDiagRTC}
+            title={useDiagRTC
+                ? 'Diagnostic RTCPeerConnection is enabled'
+                : 'Use Diagnostic RTCPeerConnection for statistics'}
+        >
+            {useDiagRTC ? 'On' : 'Off'}
+        </button>
+    </div>
+    {/if}
+
+    {#if serverInfo}
+        <div class="diag-section">
+            <h4>Stats</h4>
+            <div class="diag-grid">
+                <div class="diag-item">
+                    <span>Incoming:</span>
+                    <span>{serverInfo.diag.totalNewConnections}</span>
+                </div>
+                <div class="diag-item">
+                    <span>Connected:</span>
+                    <span>{serverInfo.diag.totalSuccessfulConnections}</span>
+                </div>
+                <div class="diag-item">
+                    <span>Failed:</span>
+                    <span>{serverInfo.diag.totalFailedConnections}</span>
+                </div>
+                <div class="diag-item">
+                    <span>Closed:</span>
+                    <span>{serverInfo.diag.totalClosedConnections}</span>
+                </div>
+            </div>
+        </div>
+    {/if}
+</div>
+
+<style>
+    .server-status {
+        border: 1px solid var(--divider-color);
+        border-radius: 0.5rem;
+        padding: 1rem;
+    }
+
+    h3 {
+        margin: 0 0 0.75rem 0;
+        font-weight: 600;
+        font-size: 1rem;
+    }
+
+    .status-item {
+        display: flex;
+        justify-content: space-between;
+        flex-wrap: wrap;
+        font-size: 0.9rem;
+        margin-bottom: 0.5rem;
+    }
+
+    .status-action {
+        align-items: center;
+        gap: 0.5rem;
+    }
+
+    .status-value {
+        font-weight: 500;
+    }
+
+    .status-value.connected {
+        color: var(--text-success);
+    }
+
+    .status-value.disconnected {
+        color: var(--text-error);
+    }
+
+    .peer-id-display {
+        font-family: monospace;
+        font-size: 0.85rem;
+        max-width: 150px;
+        overflow: hidden;
+        text-overflow: ellipsis;
+    }
+
+    .room-suffix-display {
+        font-family: monospace;
+        font-size: 0.85rem;
+        font-weight: 600;
+    }
+
+    .broadcast-row {
+        align-items: center;
+        margin-top: 0.25rem;
+    }
+
+    .diag-toggle-row {
+        align-items: center;
+        margin-top: 0.25rem;
+    }
+
+    .broadcast-label {
+        font-size: 0.9rem;
+        color: var(--text-normal);
+        cursor: pointer;
+    }
+
+    .broadcast-button {
+        font-size: 0.8rem;
+        padding: 0.2rem 0.6rem;
+        border: 1px solid var(--divider-color);
+        border-radius: 0.4rem;
+        cursor: pointer;
+        font-weight: 600;
+        transition: background-color 0.15s;
+    }
+
+    .broadcast-button.is-on {
+        background-color: var(--interactive-accent);
+        color: var(--text-on-accent);
+        border-color: var(--interactive-accent);
+    }
+
+    .broadcast-button.is-off {
+        background-color: var(--interactive-normal);
+        color: var(--text-muted);
+    }
+
+    .broadcast-button.is-off:hover {
+        background-color: var(--interactive-hover);
+        color: var(--text-normal);
+    }
+
+    .diag-section {
+        border-top: 1px solid var(--divider-color);
+        margin-top: 0.75rem;
+        padding-top: 0.75rem;
+    }
+
+    .diag-section h4 {
+        margin: 0 0 0.5rem 0;
+        font-size: 0.9rem;
+        font-weight: 600;
+    }
+
+    .diag-grid {
+        display: grid;
+        grid-template-columns: repeat(auto-fit, minmax(130px, 1fr));
+        gap: 0.35rem 0.75rem;
+    }
+
+    .diag-item {
+        display: flex;
+        justify-content: space-between;
+        font-size: 0.85rem;
+        gap: 0.5rem;
+    }
+</style>

src/features/P2PSync/P2PReplicator/P2PServerStatusPane.svelte

@@ -0,0 +1,891 @@
+<script lang="ts">
+    import { onMount } from "svelte";
+    import { EVENT_LAYOUT_READY, EVENT_REQUEST_OPEN_P2P_SETTINGS, eventHub } from "@/common/events";
+    import {
+        EVENT_SERVER_STATUS,
+        EVENT_REQUEST_STATUS,
+        EVENT_P2P_REPLICATOR_STATUS,
+        EVENT_P2P_REPLICATOR_PROGRESS,
+        type P2PServerInfo,
+    } from "@lib/replication/trystero/TrysteroReplicatorP2PServer";
+    import type { LiveSyncTrysteroReplicator } from "@lib/replication/trystero/LiveSyncTrysteroReplicator";
+    import type { P2PReplicatorStatus, P2PReplicationReport } from "@lib/replication/trystero/TrysteroReplicator";
+    import { delay, fireAndForget } from "octagonal-wheels/promises";
+    import P2PServerStatusCard from "./P2PServerStatusCard.svelte";
+    import { EVENT_SETTING_SAVED } from "@lib/events/coreEvents";
+    import type { LiveSyncBaseCore } from "@/LiveSyncBaseCore";
+    import { ConnectionStringParser } from "@lib/common/ConnectionString";
+    import type { P2PSyncSetting, RemoteConfiguration } from "@lib/common/models/setting.type";
+    import { activateP2PRemoteConfiguration, createRemoteConfigurationId } from "@lib/serviceFeatures/remoteConfig";
+    import { extractP2PRoomSuffix } from "@lib/common/utils";
+    import { SetupManager } from "@/modules/features/SetupManager";
+    import SetupRemoteP2P from "@/modules/features/SetupWizard/dialogs/SetupRemoteP2P.svelte";
+
+    interface Props {
+        liveSyncReplicator: LiveSyncTrysteroReplicator;
+        core: LiveSyncBaseCore;
+    }
+
+    let { liveSyncReplicator, core }: Props = $props();
+    let serverInfo = $state<P2PServerInfo | undefined>(undefined);
+    let replicatorInfo = $state<P2PReplicatorStatus | undefined>(undefined);
+    let decidingPeerId = $state<string | null>(null);
+    let replicatingPeerId = $state<string | null>(null);
+    let communicatingUntil = $state<Record<string, number>>({});
+    const COMMUNICATION_HOLD_MS = 2500;
+    let syncOnReplicationSetting = $state(core.services.setting.currentSettings()?.P2P_SyncOnReplication ?? "");
+    type P2PRemoteOption = {
+        id: string;
+        name: string;
+        roomSuffix: string;
+    };
+    let p2pRemoteOptions = $state<P2PRemoteOption[]>([]);
+    let selectedP2PRemoteConfigurationId = $state(
+        core.services.setting.currentSettings()?.P2P_ActiveRemoteConfigurationId ?? ""
+    );
+    let selectingP2PRemote = $state(false);
+
+    function addToList(item: string, list: string): string {
+        const items = list
+            .split(",")
+            .map((e) => e.trim())
+            .filter((e) => e);
+        if (!items.includes(item)) items.push(item);
+        return items.join(",");
+    }
+    function removeFromList(item: string, list: string): string {
+        return list
+            .split(",")
+            .map((e) => e.trim())
+            .filter((e) => e && e !== item)
+            .join(",");
+    }
+
+    function markCommunicating(peerId: string) {
+        const expiry = Date.now() + COMMUNICATION_HOLD_MS;
+        communicatingUntil = { ...communicatingUntil, [peerId]: expiry };
+        window.setTimeout(() => {
+            if ((communicatingUntil[peerId] ?? 0) <= Date.now()) {
+                const { [peerId]: _removed, ...rest } = communicatingUntil;
+                communicatingUntil = rest;
+            }
+        }, COMMUNICATION_HOLD_MS + 100);
+    }
+
+    function listP2PRemoteOptions(
+        remoteConfigurations: Record<string, RemoteConfiguration> | undefined
+    ): P2PRemoteOption[] {
+        return Object.values(remoteConfigurations ?? {})
+            .map((config) => {
+                try {
+                    const parsed = ConnectionStringParser.parse(config.uri);
+                    if (parsed.type !== "p2p") {
+                        return undefined;
+                    }
+                    return {
+                        id: config.id,
+                        name: config.name,
+                        roomSuffix: extractP2PRoomSuffix(parsed.settings.P2P_roomID ?? ""),
+                    } as P2PRemoteOption;
+                } catch {
+                    return undefined;
+                }
+            })
+            .filter((e): e is P2PRemoteOption => !!e);
+    }
+
+    function refreshP2PRemoteOptions() {
+        const settings = core.services.setting.currentSettings();
+        const options = listP2PRemoteOptions(settings.remoteConfigurations);
+        p2pRemoteOptions = options;
+        const currentSelected = settings.P2P_ActiveRemoteConfigurationId ?? "";
+        const isCurrentSelectedValid = options.some((option) => option.id === currentSelected);
+        if (options.length === 0) {
+            selectedP2PRemoteConfigurationId = "";
+            return;
+        }
+        if (currentSelected.trim() === "" || !isCurrentSelectedValid) {
+            const fallbackId = options[0].id;
+            selectedP2PRemoteConfigurationId = fallbackId;
+            if (currentSelected !== fallbackId) {
+                fireAndForget(() => applyP2PActiveRemoteSelection(fallbackId));
+            }
+            return;
+        }
+        selectedP2PRemoteConfigurationId = currentSelected;
+    }
+
+    function canEditP2PSettings() {
+        const selected = selectedP2PRemoteConfigurationId.trim();
+        if (selected === "") {
+            return false;
+        }
+        return p2pRemoteOptions.some((e) => e.id === selected);
+    }
+
+    async function requestServerStatus() {
+        await liveSyncReplicator.requestStatus();
+        eventHub.emitEvent(EVENT_REQUEST_STATUS);
+    }
+
+    onMount(() => {
+        const unsubscribe = eventHub.onEvent(EVENT_SERVER_STATUS, (status) => {
+            serverInfo = status;
+        });
+        const unsubscribeReplicatorStatus = eventHub.onEvent(EVENT_P2P_REPLICATOR_STATUS, (status) => {
+            replicatorInfo = status;
+            for (const peerId of status.replicatingFrom) {
+                markCommunicating(peerId);
+            }
+            for (const peerId of status.replicatingTo) {
+                markCommunicating(peerId);
+            }
+        });
+        const unsubscribeReplicatorProgress = eventHub.onEvent(EVENT_P2P_REPLICATOR_PROGRESS, (report) => {
+            const rep = report as P2PReplicationReport;
+            if (("fetching" in rep && rep.fetching?.isActive) || ("sending" in rep && rep.sending?.isActive)) {
+                markCommunicating(rep.peerId);
+            }
+        });
+
+        const unsubscribeSettings = eventHub.onEvent(EVENT_SETTING_SAVED, (settings) => {
+            syncOnReplicationSetting = settings?.P2P_SyncOnReplication ?? "";
+            refreshP2PRemoteOptions();
+        });
+        const unsubscribeLayoutReady = eventHub.onEvent(EVENT_LAYOUT_READY, () => {
+            refreshP2PRemoteOptions();
+            void requestServerStatus();
+        });
+
+        fireAndForget(async () => {
+            await delay(100);
+            refreshP2PRemoteOptions();
+            await requestServerStatus();
+        });
+
+        return () => {
+            unsubscribe();
+            unsubscribeReplicatorStatus();
+            unsubscribeReplicatorProgress();
+            unsubscribeSettings();
+            unsubscribeLayoutReady();
+        };
+    });
+
+    function getAcceptanceStatus(peer: P2PServerInfo["knownAdvertisements"][number]) {
+        if (peer.isTemporaryAccepted === true) return "ACCEPTED (in session)";
+        if (peer.isAccepted === true) return "ACCEPTED";
+        if (peer.isTemporaryAccepted === false) return "DENIED (in session)";
+        if (peer.isAccepted === false) return "DENIED";
+        return "NEW";
+    }
+
+    function getAcceptanceStatusClass(peer: P2PServerInfo["knownAdvertisements"][number]) {
+        if (peer.isTemporaryAccepted === true || peer.isAccepted === true) return "accepted";
+        if (peer.isTemporaryAccepted === false || peer.isAccepted === false) return "denied";
+        return "unknown";
+    }
+
+    function openConnectionSettings() {
+        eventHub.emitEvent(EVENT_REQUEST_OPEN_P2P_SETTINGS);
+    }
+
+    async function applyP2PActiveRemoteSelection(id: string) {
+        selectingP2PRemote = true;
+        try {
+            await core.services.setting.updateSettings((settings) => {
+                settings.P2P_ActiveRemoteConfigurationId = id;
+                if (id.trim() === "") {
+                    return settings;
+                }
+                const activated = activateP2PRemoteConfiguration(settings, id);
+                return activated || settings;
+            }, true);
+            const latest = core.services.setting.currentSettings();
+            syncOnReplicationSetting = latest.P2P_SyncOnReplication ?? "";
+            refreshP2PRemoteOptions();
+        } finally {
+            selectingP2PRemote = false;
+        }
+    }
+
+    async function onP2PRemoteSelected(event: Event) {
+        const target = event.currentTarget as HTMLSelectElement;
+        const id = target.value;
+        selectedP2PRemoteConfigurationId = id;
+        await applyP2PActiveRemoteSelection(id);
+    }
+
+    async function createAndSelectP2PRemote() {
+        const setupManager = core.getModule(SetupManager);
+        const dialogManager = setupManager.dialogManager;
+        const currentSettings = core.services.setting.currentSettings();
+        const p2pConf = await dialogManager.openWithExplicitCancel(SetupRemoteP2P, currentSettings);
+        if (p2pConf === "cancelled" || typeof p2pConf !== "object" || !p2pConf) {
+            return;
+        }
+        const p2pSettings = p2pConf as Partial<P2PSyncSetting>;
+        const id = createRemoteConfigurationId();
+        const roomSuffix = extractP2PRoomSuffix(p2pSettings.P2P_roomID ?? "");
+        const name = roomSuffix ? `P2P Remote (${roomSuffix})` : "P2P Remote";
+        await core.services.setting.updateSettings((settings) => {
+            const merged = {
+                ...settings,
+                ...p2pSettings,
+            };
+            const uri = ConnectionStringParser.serialize({ type: "p2p", settings: merged });
+            settings.remoteConfigurations = {
+                ...(settings.remoteConfigurations ?? {}),
+                [id]: {
+                    id,
+                    name,
+                    uri,
+                    isEncrypted: false,
+                },
+            };
+            settings.P2P_ActiveRemoteConfigurationId = id;
+            const activated = activateP2PRemoteConfiguration(settings, id);
+            return activated || settings;
+        }, true);
+        const latest = core.services.setting.currentSettings();
+        syncOnReplicationSetting = latest.P2P_SyncOnReplication ?? "";
+        refreshP2PRemoteOptions();
+    }
+
+    async function updateSelectedP2PRemote(partial: Partial<P2PSyncSetting>) {
+        const selectedId = core.services.setting.currentSettings().P2P_ActiveRemoteConfigurationId?.trim() ?? "";
+        if (selectedId === "") {
+            return;
+        }
+        await core.services.setting.updateSettings((settings) => {
+            const config = settings.remoteConfigurations?.[selectedId];
+            if (!config) {
+                return settings;
+            }
+            let parsed;
+            try {
+                parsed = ConnectionStringParser.parse(config.uri);
+            } catch {
+                return settings;
+            }
+            if (parsed.type !== "p2p") {
+                return settings;
+            }
+            const mergedP2P = {
+                ...parsed.settings,
+                ...partial,
+            };
+            const uri = ConnectionStringParser.serialize({
+                type: "p2p",
+                settings: {
+                    ...settings,
+                    ...mergedP2P,
+                },
+            });
+            settings.remoteConfigurations = {
+                ...(settings.remoteConfigurations ?? {}),
+                [selectedId]: {
+                    ...config,
+                    uri,
+                    isEncrypted: false,
+                },
+            };
+            Object.assign(settings, partial);
+            const activated = activateP2PRemoteConfiguration(settings, selectedId);
+            return activated || settings;
+        }, true);
+        syncOnReplicationSetting = core.services.setting.currentSettings()?.P2P_SyncOnReplication ?? "";
+    }
+
+    async function makeDecision(
+        peer: P2PServerInfo["knownAdvertisements"][number],
+        decision: boolean,
+        isTemporary: boolean
+    ) {
+        decidingPeerId = peer.peerId;
+        try {
+            await liveSyncReplicator.makeDecision({
+                peerId: peer.peerId,
+                name: peer.name,
+                decision,
+                isTemporary,
+            });
+            await requestServerStatus();
+        } finally {
+            decidingPeerId = null;
+        }
+    }
+
+    async function revokeDecision(peer: P2PServerInfo["knownAdvertisements"][number]) {
+        decidingPeerId = peer.peerId;
+        try {
+            await liveSyncReplicator.revokeDecision({
+                peerId: peer.peerId,
+                name: peer.name,
+            });
+            await requestServerStatus();
+        } finally {
+            decidingPeerId = null;
+        }
+    }
+
+    async function startReplication(peer: P2PServerInfo["knownAdvertisements"][number]) {
+        replicatingPeerId = peer.peerId;
+        try {
+            const pullResult = await liveSyncReplicator.replicateFrom(peer.peerId, true);
+            if (pullResult?.ok) {
+                await liveSyncReplicator.requestSynchroniseToPeer(peer.peerId);
+            }
+            await requestServerStatus();
+        } finally {
+            replicatingPeerId = null;
+        }
+    }
+
+    function isAccepted(peer: P2PServerInfo["knownAdvertisements"][number]) {
+        return peer.isTemporaryAccepted === true || peer.isAccepted === true;
+    }
+
+    function isWatching(peerId: string) {
+        return replicatorInfo?.watchingPeers?.includes(peerId) ?? false;
+    }
+
+    function toggleWatch(peerId: string) {
+        if (!canEditP2PSettings()) {
+            return;
+        }
+        if (isWatching(peerId)) {
+            liveSyncReplicator.unwatchPeer(peerId);
+        } else {
+            liveSyncReplicator.watchPeer(peerId);
+        }
+    }
+
+    function isCommunicating(peerId: string) {
+        const to = replicatorInfo?.replicatingTo ?? [];
+        const from = replicatorInfo?.replicatingFrom ?? [];
+        const isLiveCommunicating = to.includes(peerId) || from.includes(peerId);
+        const isHeldCommunicating = (communicatingUntil[peerId] ?? 0) > Date.now();
+        return isLiveCommunicating || isHeldCommunicating;
+    }
+
+    function isSyncTarget(peerName: string) {
+        return syncOnReplicationSetting
+            .split(",")
+            .map((e) => e.trim())
+            .filter((e) => e)
+            .includes(peerName);
+    }
+
+    async function toggleSyncTarget(peer: P2PServerInfo["knownAdvertisements"][number]) {
+        if (!canEditP2PSettings()) {
+            return;
+        }
+        const currentValue = core.services.setting.currentSettings()?.P2P_SyncOnReplication ?? "";
+        const newValue = isSyncTarget(peer.name)
+            ? removeFromList(peer.name, currentValue)
+            : addToList(peer.name, currentValue);
+        await updateSelectedP2PRemote({ P2P_SyncOnReplication: newValue });
+    }
+</script>
+
+<div class="p2p-container">
+    <div class="pane-header">
+        <h2>P2P Status</h2>
+        <div class="pane-header-actions">
+            <div class="remote-picker-wrap">
+                <select
+                    class="remote-picker"
+                    value={selectedP2PRemoteConfigurationId}
+                    onchange={onP2PRemoteSelected}
+                    disabled={selectingP2PRemote}
+                    aria-label="Select active P2P remote"
+                    title="Select active P2P remote"
+                >
+                    {#if p2pRemoteOptions.length === 0}
+                        <option value="">Select P2P remote...</option>
+                    {/if}
+                    {#each p2pRemoteOptions as option}
+                        <option value={option.id}>
+                            {option.name}{option.roomSuffix ? ` (${option.roomSuffix})` : ""}
+                        </option>
+                    {/each}
+                </select>
+                <button
+                    class="icon-button"
+                    onclick={() => createAndSelectP2PRemote()}
+                    title="Create P2P remote"
+                    aria-label="Create P2P remote"
+                >
+                    +
+                </button>
+            </div>
+            <button
+                class="icon-button"
+                onclick={openConnectionSettings}
+                title="Open P2P Setup..."
+                aria-label="Open P2P Setup..."
+            >
+                ⚙
+            </button>
+        </div>
+    </div>
+
+    {#if !canEditP2PSettings()}
+        <p class="warning-line">Please select an active P2P remote configuration to change P2P sync targets.</p>
+    {/if}
+
+    <P2PServerStatusCard {liveSyncReplicator} {core} />
+
+    <div class="peers-section">
+        <div class="peers-header">
+            <h3>Detected Peers</h3>
+            <button class="refresh" onclick={requestServerStatus}>Refresh</button>
+        </div>
+
+        {#if serverInfo && serverInfo.knownAdvertisements.length > 0}
+            <div class="peers-list">
+                {#each serverInfo.knownAdvertisements as peer (peer.peerId)}
+                    <div class="peer-item">
+                        <div class="peer-info">
+                            <div class="peer-name">
+                                {peer.name} :
+                                <span class="peer-id-mini" title={peer.peerId}>({peer.peerId.slice(0, 8)})</span>
+                                {#if isCommunicating(peer.peerId)}
+                                    <span class="comm-icon" title="Communicating" aria-label="Communicating">📡</span>
+                                {/if}
+                            </div>
+                            <div class="peer-meta">
+                                <span class="badge">{peer.platform}</span>
+                            </div>
+                        </div>
+                        <div class="peer-actions">
+                            {#if isAccepted(peer)}
+                                <div class="decision-row accepted-row">
+                                    <span class="badge status-chip {getAcceptanceStatusClass(peer)}">
+                                        {getAcceptanceStatus(peer)}
+                                    </span>
+                                    <button
+                                        class="emoji-button"
+                                        disabled={replicatingPeerId !== null}
+                                        title={replicatingPeerId === peer.peerId ? "Replicating..." : "Replicate now"}
+                                        aria-label={replicatingPeerId === peer.peerId ? "Replicating" : "Replicate now"}
+                                        onclick={() => startReplication(peer)}
+                                    >
+                                        {replicatingPeerId === peer.peerId ? "⏳" : "🔄"}
+                                    </button>
+                                    <button
+                                        class="action-button"
+                                        disabled={decidingPeerId !== null}
+                                        onclick={() => revokeDecision(peer)}
+                                    >
+                                        Revoke
+                                    </button>
+                                </div>
+                                <div class="decision-row watch-row">
+                                    <span class="decision-label">WATCH</span>
+                                    <button
+                                        class="emoji-button {isWatching(peer.peerId) ? 'is-watching' : ''}"
+                                        title={isWatching(peer.peerId)
+                                            ? "Watching this peer \u2014 click to stop"
+                                            : "Watch this peer's changes"}
+                                        aria-label={isWatching(peer.peerId) ? "Stop watching" : "Watch peer"}
+                                        disabled={!canEditP2PSettings()}
+                                        onclick={() => toggleWatch(peer.peerId)}
+                                    >
+                                        {isWatching(peer.peerId) ? "🔔" : "🔕"}
+                                    </button>
+                                </div>
+                                <div class="decision-row watch-row">
+                                    <span class="decision-label">SYNC</span>
+                                    <button
+                                        class="emoji-button {isSyncTarget(peer.name) ? 'is-watching' : ''}"
+                                        title={isSyncTarget(peer.name)
+                                            ? "Sync target \u2014 click to remove"
+                                            : "Set as sync target"}
+                                        aria-label={isSyncTarget(peer.name) ? "Remove sync target" : "Set sync target"}
+                                        disabled={!canEditP2PSettings()}
+                                        onclick={() => toggleSyncTarget(peer)}
+                                    >
+                                        {isSyncTarget(peer.name) ? "🔗" : "⛓️‍💥"}
+                                    </button>
+                                </div>
+                            {:else}
+                                <div class="decision-status">
+                                    <span class="badge status-chip {getAcceptanceStatusClass(peer)}">
+                                        {getAcceptanceStatus(peer)}
+                                    </span>
+                                </div>
+                                <div class="decision-row">
+                                    <span class="decision-label">PERMANENT</span>
+                                    <button
+                                        class="emoji-button"
+                                        title="Allow permanently"
+                                        aria-label="Allow permanently"
+                                        disabled={decidingPeerId !== null}
+                                        onclick={() => makeDecision(peer, true, false)}
+                                    >
+                                        ✅
+                                    </button>
+                                    <button
+                                        class="emoji-button mod-warning"
+                                        title="Deny permanently"
+                                        aria-label="Deny permanently"
+                                        disabled={decidingPeerId !== null}
+                                        onclick={() => makeDecision(peer, false, false)}
+                                    >
+                                        🚫
+                                    </button>
+                                </div>
+                                <div class="decision-row">
+                                    <span class="decision-label">SESSION</span>
+                                    <button
+                                        class="emoji-button"
+                                        title="Allow in session"
+                                        aria-label="Allow in session"
+                                        disabled={decidingPeerId !== null}
+                                        onclick={() => makeDecision(peer, true, true)}
+                                    >
+                                        ✅
+                                    </button>
+                                    <button
+                                        class="emoji-button mod-warning"
+                                        title="Deny in session"
+                                        aria-label="Deny in session"
+                                        disabled={decidingPeerId !== null}
+                                        onclick={() => makeDecision(peer, false, true)}
+                                    >
+                                        🚫
+                                    </button>
+                                </div>
+                            {/if}
+                            {#if !isAccepted(peer) && (peer.isAccepted !== undefined || peer.isTemporaryAccepted !== undefined)}
+                                <button
+                                    class="action-button revoke-inline"
+                                    disabled={decidingPeerId !== null}
+                                    onclick={() => revokeDecision(peer)}
+                                >
+                                    Revoke
+                                </button>
+                            {/if}
+                        </div>
+                    </div>
+                {/each}
+            </div>
+        {:else if serverInfo}
+            <p class="no-peers">No devices available. Waiting for other devices to connect...</p>
+        {:else}
+            <p class="no-peers">Fetching status...</p>
+        {/if}
+    </div>
+</div>
+
+<style>
+    .p2p-container {
+        display: flex;
+        flex-direction: column;
+        gap: 1rem;
+    }
+
+    .peers-section {
+        border: 1px solid var(--divider-color);
+        border-radius: 0.5rem;
+        padding: 1rem;
+    }
+
+    .pane-header {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        flex-wrap: wrap;
+        gap: 0.5rem;
+    }
+
+    .pane-header-actions {
+        display: flex;
+        align-items: center;
+        gap: 0.4rem;
+        min-width: 0;
+    }
+
+    .remote-picker-wrap {
+        display: inline-flex;
+        gap: 0.3rem;
+        align-items: center;
+        min-width: 0;
+    }
+
+    .remote-picker {
+        max-width: 10rem;
+        min-width: 1em;
+        flex-shrink: 1;
+        height: 1.9rem;
+        border: 1px solid var(--divider-color);
+        border-radius: 0.4rem;
+        background-color: var(--interactive-normal);
+        color: var(--text-normal);
+        padding: 0 0.45rem;
+    }
+
+    .warning-line {
+        margin: -0.2rem 0 0;
+        font-size: 0.82rem;
+        color: var(--text-warning);
+    }
+
+    .pane-header h2 {
+        margin: 0;
+        font-size: 1.1rem;
+        font-weight: 700;
+        white-space: nowrap;
+    }
+
+    .icon-button {
+        width: 1.9rem;
+        height: 1.9rem;
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        font-size: 1rem;
+        line-height: 1;
+        border: 1px solid var(--divider-color);
+        border-radius: 0.4rem;
+        background-color: var(--interactive-normal);
+        color: var(--text-normal);
+        cursor: pointer;
+        flex-shrink: 0;
+    }
+
+    .icon-button:hover {
+        background-color: var(--interactive-hover);
+    }
+
+    .peers-header {
+        display: flex;
+        flex-wrap: wrap;
+        justify-content: space-between;
+        align-items: center;
+        gap: 0.5rem;
+        margin-bottom: 0.75rem;
+    }
+
+    h3 {
+        margin: 0;
+        font-weight: 600;
+        font-size: 1rem;
+    }
+
+    .refresh {
+        font-size: 0.8rem;
+        padding: 0.2rem 0.5rem;
+        border: 1px solid var(--divider-color);
+        border-radius: 0.3rem;
+        background-color: var(--interactive-normal);
+        color: var(--text-normal);
+        cursor: pointer;
+    }
+
+    .refresh:hover {
+        background-color: var(--interactive-hover);
+    }
+
+    .peers-list {
+        display: flex;
+        flex-direction: column;
+        gap: 0.5rem;
+    }
+
+    .peer-item {
+        display: flex;
+        flex-direction: column;
+        align-items: stretch;
+        gap: 0.75rem;
+        padding: 0.75rem;
+        background-color: var(--background-secondary);
+        border: 1px solid var(--divider-color);
+        border-radius: 0.4rem;
+    }
+
+    .peer-info {
+        flex: 1;
+        min-width: 0;
+    }
+
+    .peer-name {
+        font-weight: 600;
+        margin-bottom: 0.25rem;
+        font-size: 0.9rem;
+        display: flex;
+        align-items: center;
+        gap: 0.35rem;
+    }
+
+    .peer-meta {
+        display: flex;
+        gap: 0.5rem;
+        font-size: 0.8rem;
+        flex-wrap: wrap;
+    }
+
+    .badge {
+        background-color: var(--background-tertiary);
+        padding: 0.1rem 0.4rem;
+        border-radius: 0.25rem;
+    }
+
+    .status-chip {
+        font-weight: 600;
+    }
+
+    .status-chip.accepted {
+        background-color: var(--background-modifier-success);
+        color: var(--text-normal);
+    }
+
+    .status-chip.denied {
+        background-color: var(--background-modifier-error);
+        color: var(--text-normal);
+    }
+
+    .status-chip.unknown {
+        background-color: var(--background-modifier-border);
+        color: var(--text-muted);
+    }
+
+    .peer-id-mini {
+        font-family: monospace;
+        color: var(--text-muted);
+        font-size: 0.75rem;
+    }
+
+    .comm-icon {
+        font-size: 0.8rem;
+        line-height: 1;
+        animation: pulse-comm 1.2s ease-in-out infinite;
+    }
+
+    @keyframes pulse-comm {
+        0% {
+            opacity: 0.55;
+            transform: scale(0.95);
+        }
+        50% {
+            opacity: 1;
+            transform: scale(1);
+        }
+        100% {
+            opacity: 0.55;
+            transform: scale(0.95);
+        }
+    }
+
+    .peer-actions {
+        display: flex;
+        flex-direction: column;
+        gap: 0.35rem;
+        width: 100%;
+        min-width: 0;
+    }
+
+    .decision-status {
+        display: flex;
+        justify-content: flex-start;
+    }
+
+    .decision-row {
+        display: grid;
+        grid-template-columns: 1fr auto auto;
+        align-items: center;
+        gap: 0.35rem;
+    }
+
+    .accepted-row {
+        grid-template-columns: 1fr auto auto;
+    }
+
+    .decision-label {
+        font-size: 0.7rem;
+        font-weight: 700;
+        color: var(--text-muted);
+        letter-spacing: 0.03em;
+    }
+
+    .action-button {
+        font-size: 0.75rem;
+        padding: 0.2rem 0.45rem;
+        border: 1px solid var(--divider-color);
+        border-radius: 0.3rem;
+        background-color: var(--interactive-normal);
+        color: var(--text-normal);
+        cursor: pointer;
+        width: auto;
+        white-space: nowrap;
+        overflow: hidden;
+        text-overflow: ellipsis;
+    }
+
+    .emoji-button {
+        width: 2rem;
+        height: 1.7rem;
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        border: 1px solid var(--divider-color);
+        border-radius: 0.3rem;
+        background-color: var(--interactive-normal);
+        cursor: pointer;
+        padding: 0;
+        line-height: 1;
+    }
+
+    .emoji-button.mod-warning {
+        background-color: var(--background-modifier-error);
+    }
+
+    .emoji-button.is-watching {
+        background-color: var(--interactive-accent);
+        color: var(--text-on-accent);
+        border-color: var(--interactive-accent);
+    }
+
+    .emoji-button:hover:not(:disabled) {
+        background-color: var(--interactive-hover);
+    }
+
+    .emoji-button.mod-warning:hover:not(:disabled) {
+        filter: brightness(0.95);
+    }
+
+    .watch-row {
+        margin-top: 0.25rem;
+    }
+
+    .action-button:hover:not(:disabled) {
+        background-color: var(--interactive-hover);
+    }
+
+    .action-button.mod-warning {
+        background-color: var(--background-modifier-error);
+    }
+
+    .action-button:disabled {
+        opacity: 0.6;
+        cursor: not-allowed;
+    }
+
+    .emoji-button:disabled {
+        opacity: 0.6;
+        cursor: not-allowed;
+    }
+
+    .revoke-inline {
+        justify-self: start;
+    }
+
+    .no-peers {
+        text-align: center;
+        color: var(--text-muted);
+        font-size: 0.9rem;
+        padding: 1rem;
+    }
+</style>

src/features/P2PSync/P2PReplicator/P2PServerStatusPaneView.ts

@@ -0,0 +1,43 @@
+import { WorkspaceLeaf } from "@/deps.ts";
+import { mount } from "svelte";
+import { SvelteItemView } from "@/common/SvelteItemView.ts";
+import type { LiveSyncBaseCore } from "@/LiveSyncBaseCore.ts";
+import type { P2PPaneParams } from "@/lib/src/replication/trystero/UseP2PReplicatorResult";
+import P2PServerStatusPane from "./P2PServerStatusPane.svelte";
+
+export const VIEW_TYPE_P2P_SERVER_STATUS = "p2p-server-status";
+
+export class P2PServerStatusPaneView extends SvelteItemView {
+    core: LiveSyncBaseCore;
+    private _p2pResult: P2PPaneParams;
+    override icon = "waypoints";
+    override navigation = false;
+
+    constructor(leaf: WorkspaceLeaf, core: LiveSyncBaseCore, p2pResult: P2PPaneParams) {
+        super(leaf);
+        this.core = core;
+        this._p2pResult = p2pResult;
+    }
+
+    override getIcon(): string {
+        return "waypoints";
+    }
+
+    getViewType() {
+        return VIEW_TYPE_P2P_SERVER_STATUS;
+    }
+
+    getDisplayText() {
+        return "P2P Status";
+    }
+
+    instantiateComponent(target: HTMLElement) {
+        return mount(P2PServerStatusPane, {
+            target,
+            props: {
+                liveSyncReplicator: this._p2pResult.replicator,
+                core: this.core,
+            },
+        });
+    }
+}

src/main.ts

@@ -1,5 +1,6 @@
-import { Notice, Plugin, type App, type PluginManifest } from "./deps";
-
+import { getLanguage, Notice, Plugin, type App, type PluginManifest } from "./deps";
+import { setGetLanguage } from "./lib/src/common/coreEnvFunctions.ts";
+setGetLanguage(getLanguage);
 import { LiveSyncCommands } from "./features/LiveSyncCommands.ts";
 import { HiddenFileSync } from "./features/HiddenFileSync/CmdHiddenFileSync.ts";
 import { ConfigSync } from "./features/ConfigSync/CmdConfigSync.ts";
@@ -11,8 +12,6 @@ import { ModuleObsidianEvents } from "./modules/essentialObsidian/ModuleObsidian
 import { ModuleObsidianSettingDialogue } from "./modules/features/ModuleObsidianSettingTab.ts";
 import { ModuleObsidianDocumentHistory } from "./modules/features/ModuleObsidianDocumentHistory.ts";
 import { ModuleObsidianGlobalHistory } from "./modules/features/ModuleGlobalHistory.ts";
-import { ModuleIntegratedTest } from "./modules/extras/ModuleIntegratedTest.ts";
-import { ModuleReplicateTest } from "./modules/extras/ModuleReplicateTest.ts";
 import { LocalDatabaseMaintenance } from "./features/LocalDatabaseMainte/CmdLocalDatabaseMainte.ts";
 import type { InjectableServiceHub } from "@lib/services/implements/injectable/InjectableServiceHub.ts";
 import { ObsidianServiceHub } from "./modules/services/ObsidianServiceHub.ts";
@@ -43,6 +42,7 @@ import { useSetupManagerHandlersFeature } from "./serviceFeatures/setupObsidian/
 import { useP2PReplicatorFeature } from "@lib/replication/trystero/useP2PReplicatorFeature.ts";
 import { useP2PReplicatorCommands } from "@lib/replication/trystero/useP2PReplicatorCommands.ts";
 import { useP2PReplicatorUI } from "./serviceFeatures/useP2PReplicatorUI.ts";
+import { createOpenReplicationUI, createOpenRebuildUI } from "./features/P2PSync/P2PReplicator/P2PReplicationUI.ts";
 export type LiveSyncCore = LiveSyncBaseCore<ObsidianServiceContext, LiveSyncCommands>;
 export default class ObsidianLiveSyncPlugin extends Plugin {
     core: LiveSyncCore;
@@ -154,8 +154,6 @@ export default class ObsidianLiveSyncPlugin extends Plugin {
                     new ModuleInteractiveConflictResolver(this, core),
                     new ModuleObsidianGlobalHistory(this, core),
                     new ModuleDev(this, core),
-                    new ModuleReplicateTest(this, core),
-                    new ModuleIntegratedTest(this, core),
                     new SetupManager(core), // this should be moved to core?
                     new ModuleMigration(core),
                 ];
@@ -175,7 +173,13 @@ export default class ObsidianLiveSyncPlugin extends Plugin {
                 const curriedFeature = () => featuresInitialiser(core);
                 core.services.appLifecycle.onLayoutReady.addHandler(curriedFeature);
                 const setupManager = core.getModule(SetupManager);
-
+                const replicator = useP2PReplicatorFeature(
+                    core,
+                    createOpenReplicationUI(this.app),
+                    createOpenRebuildUI(this.app)
+                );
+                useP2PReplicatorCommands(core, replicator);
+                useP2PReplicatorUI(core, core, replicator);
                 useRemoteConfiguration(core);
 
                 useSetupProtocolFeature(core, setupManager);
@@ -189,9 +193,6 @@ export default class ObsidianLiveSyncPlugin extends Plugin {
                 //     VIEW_TYPE_P2P,
                 //     (leaf: any) => new P2PReplicatorPaneView(leaf, core, p2pReplicatorResult!),
                 // ]);
-                const replicator = useP2PReplicatorFeature(core);
-                useP2PReplicatorCommands(core, replicator);
-                useP2PReplicatorUI(core, core, replicator);
             }
         );
     }

src/modules/core/ModuleReplicator.ts

@@ -1,3 +1,4 @@
+import type PouchDB from "pouchdb-core";
 import { fireAndForget } from "octagonal-wheels/promises";
 import { AbstractModule } from "../AbstractModule";
 import { Logger, LOG_LEVEL_NOTICE, LOG_LEVEL_INFO } from "octagonal-wheels/common/logger";

src/modules/core/ModuleReplicatorP2P.ts

@@ -1,25 +0,0 @@
-import { REMOTE_P2P, type RemoteDBSettings } from "../../lib/src/common/types";
-import type { LiveSyncAbstractReplicator } from "../../lib/src/replication/LiveSyncAbstractReplicator";
-import { AbstractModule } from "../AbstractModule";
-import { LiveSyncTrysteroReplicator } from "../../lib/src/replication/trystero/LiveSyncTrysteroReplicator";
-import type { LiveSyncCore } from "../../main";
-
-// Note:
-// This module registers only the `getNewReplicator` handler for the P2P replicator.
-// `useP2PReplicator` (see P2PReplicatorCore.ts) already registers the same `getNewReplicator`
-// handler internally, so this module is redundant in environments that call `useP2PReplicator`.
-// Register this module only in environments that do NOT use `useP2PReplicator` (e.g. CLI).
-// In other words: just resolving `getNewReplicator` via this module is all that is needed
-// to satisfy what `useP2PReplicator` requires from the replicator service.
-export class ModuleReplicatorP2P extends AbstractModule {
-    _anyNewReplicator(settingOverride: Partial<RemoteDBSettings> = {}): Promise<LiveSyncAbstractReplicator | false> {
-        const settings = { ...this.settings, ...settingOverride };
-        if (settings.remoteType == REMOTE_P2P) {
-            return Promise.resolve(new LiveSyncTrysteroReplicator(this.core));
-        }
-        return Promise.resolve(false);
-    }
-    override onBindFunction(core: LiveSyncCore, services: typeof core.services): void {
-        services.replicator.getNewReplicator.addHandler(this._anyNewReplicator.bind(this));
-    }
-}

src/modules/coreFeatures/ModuleRedFlag.ts

@@ -1,331 +0,0 @@
-import { LOG_LEVEL_INFO, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/logger";
-import { normalizePath } from "../../deps.ts";
-import {
-    FlagFilesHumanReadable,
-    FlagFilesOriginal,
-    REMOTE_MINIO,
-    TweakValuesShouldMatchedTemplate,
-    type ObsidianLiveSyncSettings,
-} from "../../lib/src/common/types.ts";
-import { AbstractModule } from "../AbstractModule.ts";
-import type { LiveSyncCore } from "../../main.ts";
-import FetchEverything from "../features/SetupWizard/dialogs/FetchEverything.svelte";
-import RebuildEverything from "../features/SetupWizard/dialogs/RebuildEverything.svelte";
-import { extractObject } from "octagonal-wheels/object";
-import { SvelteDialogManagerBase } from "@lib/UI/svelteDialog.ts";
-import type { ServiceContext } from "@lib/services/base/ServiceBase.ts";
-
-export class ModuleRedFlag extends AbstractModule {
-    async isFlagFileExist(path: string) {
-        const redflag = await this.core.storageAccess.isExists(normalizePath(path));
-        if (redflag) {
-            return true;
-        }
-        return false;
-    }
-
-    async deleteFlagFile(path: string) {
-        try {
-            const isFlagged = await this.core.storageAccess.isExists(normalizePath(path));
-            if (isFlagged) {
-                await this.core.storageAccess.delete(path, true);
-            }
-        } catch (ex) {
-            this._log(`Could not delete ${path}`);
-            this._log(ex, LOG_LEVEL_VERBOSE);
-        }
-    }
-
-    isSuspendFlagActive = async () => await this.isFlagFileExist(FlagFilesOriginal.SUSPEND_ALL);
-    isRebuildFlagActive = async () =>
-        (await this.isFlagFileExist(FlagFilesOriginal.REBUILD_ALL)) ||
-        (await this.isFlagFileExist(FlagFilesHumanReadable.REBUILD_ALL));
-    isFetchAllFlagActive = async () =>
-        (await this.isFlagFileExist(FlagFilesOriginal.FETCH_ALL)) ||
-        (await this.isFlagFileExist(FlagFilesHumanReadable.FETCH_ALL));
-
-    async cleanupRebuildFlag() {
-        await this.deleteFlagFile(FlagFilesOriginal.REBUILD_ALL);
-        await this.deleteFlagFile(FlagFilesHumanReadable.REBUILD_ALL);
-    }
-
-    async cleanupFetchAllFlag() {
-        await this.deleteFlagFile(FlagFilesOriginal.FETCH_ALL);
-        await this.deleteFlagFile(FlagFilesHumanReadable.FETCH_ALL);
-    }
-    // dialogManager = new SvelteDialogManagerBase(this.core);
-    get dialogManager(): SvelteDialogManagerBase<ServiceContext> {
-        return this.core.services.UI.dialogManager;
-    }
-
-    /**
-     * Adjust setting to remote if needed.
-     * @param extra result of dialogues that may contain preventFetchingConfig flag (e.g, from FetchEverything or RebuildEverything)
-     * @param config current configuration to retrieve remote preferred config
-     */
-    async adjustSettingToRemoteIfNeeded(extra: { preventFetchingConfig: boolean }, config: ObsidianLiveSyncSettings) {
-        if (extra && extra.preventFetchingConfig) {
-            return;
-        }
-
-        // Remote configuration fetched and applied.
-        if (await this.adjustSettingToRemote(config)) {
-            config = this.core.settings;
-        } else {
-            this._log("Remote configuration not applied.", LOG_LEVEL_NOTICE);
-        }
-        console.debug(config);
-    }
-
-    /**
-     * Adjust setting to remote configuration.
-     * @param config current configuration to retrieve remote preferred config
-     * @returns updated configuration if applied, otherwise null.
-     */
-    async adjustSettingToRemote(config: ObsidianLiveSyncSettings) {
-        // Fetch remote configuration unless prevented.
-        const SKIP_FETCH = "Skip and proceed";
-        const RETRY_FETCH = "Retry (recommended)";
-        let canProceed = false;
-        do {
-            const remoteTweaks = await this.services.tweakValue.fetchRemotePreferred(config);
-            if (!remoteTweaks) {
-                const choice = await this.core.confirm.askSelectStringDialogue(
-                    "Could not fetch configuration from remote. If you are new to the Self-hosted LiveSync, this might be expected. If not, you should check your network or server settings.",
-                    [SKIP_FETCH, RETRY_FETCH] as const,
-                    {
-                        defaultAction: RETRY_FETCH,
-                        timeout: 0,
-                        title: "Fetch Remote Configuration Failed",
-                    }
-                );
-                if (choice === SKIP_FETCH) {
-                    canProceed = true;
-                }
-            } else {
-                const necessary = extractObject(TweakValuesShouldMatchedTemplate, remoteTweaks);
-                // Check if any necessary tweak value is different from current config.
-                const differentItems = Object.entries(necessary).filter(([key, value]) => {
-                    return (config as any)[key] !== value;
-                });
-                if (differentItems.length === 0) {
-                    this._log(
-                        "Remote configuration matches local configuration. No changes applied.",
-                        LOG_LEVEL_NOTICE
-                    );
-                } else {
-                    await this.core.confirm.askSelectStringDialogue(
-                        "Your settings differed slightly from the server's. The plug-in has supplemented the incompatible parts with the server settings!",
-                        ["OK"] as const,
-                        {
-                            defaultAction: "OK",
-                            timeout: 0,
-                        }
-                    );
-                }
-
-                config = {
-                    ...config,
-                    ...Object.fromEntries(differentItems),
-                } satisfies ObsidianLiveSyncSettings;
-                this.core.settings = config;
-                await this.core.services.setting.saveSettingData();
-                this._log("Remote configuration applied.", LOG_LEVEL_NOTICE);
-                canProceed = true;
-                return this.core.settings;
-            }
-        } while (!canProceed);
-    }
-
-    /**
-     * Process vault initialisation with suspending file watching and sync.
-     * @param proc process to be executed during initialisation, should return true if can be continued, false if app is unable to continue the process.
-     * @param keepSuspending  whether to keep suspending file watching after the process.
-     * @returns result of the process, or false if error occurs.
-     */
-    async processVaultInitialisation(proc: () => Promise<boolean>, keepSuspending = false) {
-        try {
-            // Disable batch saving and file watching during initialisation.
-            this.settings.batchSave = false;
-            await this.services.setting.suspendAllSync();
-            await this.services.setting.suspendExtraSync();
-            this.settings.suspendFileWatching = true;
-            await this.saveSettings();
-            try {
-                const result = await proc();
-                return result;
-            } catch (ex) {
-                this._log("Error during vault initialisation process.", LOG_LEVEL_NOTICE);
-                this._log(ex, LOG_LEVEL_VERBOSE);
-                return false;
-            }
-        } catch (ex) {
-            this._log("Error during vault initialisation.", LOG_LEVEL_NOTICE);
-            this._log(ex, LOG_LEVEL_VERBOSE);
-            return false;
-        } finally {
-            if (!keepSuspending) {
-                // Re-enable file watching after initialisation.
-                this.settings.suspendFileWatching = false;
-                await this.saveSettings();
-            }
-        }
-    }
-
-    /**
-     * Handle the rebuild everything scheduled operation.
-     * @returns true if can be continued, false if app restart is needed.
-     */
-    async onRebuildEverythingScheduled() {
-        const method = await this.dialogManager.openWithExplicitCancel(RebuildEverything);
-        if (method === "cancelled") {
-            // Clean up the flag file and restart the app.
-            this._log("Rebuild everything cancelled by user.", LOG_LEVEL_NOTICE);
-            await this.cleanupRebuildFlag();
-            this.services.appLifecycle.performRestart();
-            return false;
-        }
-        const { extra } = method;
-        await this.adjustSettingToRemoteIfNeeded(extra, this.settings);
-        return await this.processVaultInitialisation(async () => {
-            await this.core.rebuilder.$rebuildEverything();
-            await this.cleanupRebuildFlag();
-            this._log("Rebuild everything operation completed.", LOG_LEVEL_NOTICE);
-            return true;
-        });
-    }
-    /**
-     * Handle the fetch all scheduled operation.
-     * @returns true if can be continued, false if app restart is needed.
-     */
-    async onFetchAllScheduled() {
-        const method = await this.dialogManager.openWithExplicitCancel(FetchEverything);
-        if (method === "cancelled") {
-            this._log("Fetch everything cancelled by user.", LOG_LEVEL_NOTICE);
-            // Clean up the flag file and restart the app.
-            await this.cleanupFetchAllFlag();
-            this.services.appLifecycle.performRestart();
-            return false;
-        }
-        const { vault, extra } = method;
-        // If remote is MinIO, makeLocalChunkBeforeSync is not available. (because no-deduplication on sending).
-        const makeLocalChunkBeforeSyncAvailable = this.settings.remoteType !== REMOTE_MINIO;
-        const mapVaultStateToAction = {
-            identical: {
-                // If both are identical, no need to make local files/chunks before sync,
-                // Just for the efficiency, chunks should be made before sync.
-                makeLocalChunkBeforeSync: makeLocalChunkBeforeSyncAvailable,
-                makeLocalFilesBeforeSync: false,
-            },
-            independent: {
-                // If both are independent, nothing needs to be made before sync.
-                // Respect the remote state.
-                makeLocalChunkBeforeSync: false,
-                makeLocalFilesBeforeSync: false,
-            },
-            unbalanced: {
-                // If both are unbalanced, local files should be made before sync to avoid data loss.
-                // Then, chunks should be made before sync for the efficiency, but also the metadata made and should be detected as conflicting.
-                makeLocalChunkBeforeSync: false,
-                makeLocalFilesBeforeSync: true,
-            },
-            cancelled: {
-                // Cancelled case, not actually used.
-                makeLocalChunkBeforeSync: false,
-                makeLocalFilesBeforeSync: false,
-            },
-        } as const;
-
-        return await this.processVaultInitialisation(async () => {
-            await this.adjustSettingToRemoteIfNeeded(extra, this.settings);
-            // Okay, proceed to fetch everything.
-            const { makeLocalChunkBeforeSync, makeLocalFilesBeforeSync } = mapVaultStateToAction[vault];
-            this._log(
-                `Fetching everything with settings: makeLocalChunkBeforeSync=${makeLocalChunkBeforeSync}, makeLocalFilesBeforeSync=${makeLocalFilesBeforeSync}`,
-                LOG_LEVEL_INFO
-            );
-            await this.core.rebuilder.$fetchLocal(makeLocalChunkBeforeSync, !makeLocalFilesBeforeSync);
-            await this.cleanupFetchAllFlag();
-            this._log("Fetch everything operation completed. Vault files will be gradually synced.", LOG_LEVEL_NOTICE);
-            return true;
-        });
-    }
-
-    async onSuspendAllScheduled() {
-        this._log("SCRAM is detected. All operations are suspended.", LOG_LEVEL_NOTICE);
-        return await this.processVaultInitialisation(async () => {
-            this._log(
-                "All operations are suspended as per SCRAM.\nLogs will be written to the file. This might be a performance impact.",
-                LOG_LEVEL_NOTICE
-            );
-            this.settings.writeLogToTheFile = true;
-            await this.core.services.setting.saveSettingData();
-            return Promise.resolve(false);
-        }, true);
-    }
-
-    async verifyAndUnlockSuspension() {
-        if (!this.settings.suspendFileWatching) {
-            return true;
-        }
-        if (
-            (await this.core.confirm.askYesNoDialog(
-                "Do you want to resume file and database processing, and restart obsidian now?",
-                { defaultOption: "Yes", timeout: 15 }
-            )) != "yes"
-        ) {
-            // TODO: Confirm actually proceed to next process.
-            return true;
-        }
-        this.settings.suspendFileWatching = false;
-        await this.saveSettings();
-        this.services.appLifecycle.performRestart();
-        return false;
-    }
-
-    private async processFlagFilesOnStartup(): Promise<boolean> {
-        const isFlagSuspensionActive = await this.isSuspendFlagActive();
-        const isFlagRebuildActive = await this.isRebuildFlagActive();
-        const isFlagFetchAllActive = await this.isFetchAllFlagActive();
-        // TODO: Address the case when both flags are active (very unlikely though).
-        // if(isFlagFetchAllActive && isFlagRebuildActive) {
-        //     const message = "Rebuild everything and Fetch everything flags are both detected.";
-        //     await this.core.confirm.askSelectStringDialogue(
-        //         "Both Rebuild Everything and Fetch Everything flags are detected. Please remove one of them and restart the app.",
-        //         ["OK"] as const,)
-        if (isFlagFetchAllActive) {
-            const res = await this.onFetchAllScheduled();
-            if (res) {
-                return await this.verifyAndUnlockSuspension();
-            }
-            return false;
-        }
-        if (isFlagRebuildActive) {
-            const res = await this.onRebuildEverythingScheduled();
-            if (res) {
-                return await this.verifyAndUnlockSuspension();
-            }
-            return false;
-        }
-        if (isFlagSuspensionActive) {
-            const res = await this.onSuspendAllScheduled();
-            return res;
-        }
-        return true;
-    }
-
-    async _everyOnLayoutReady(): Promise<boolean> {
-        try {
-            const flagProcessResult = await this.processFlagFilesOnStartup();
-            return flagProcessResult;
-        } catch (ex) {
-            this._log("Something went wrong on FlagFile Handling", LOG_LEVEL_NOTICE);
-            this._log(ex, LOG_LEVEL_VERBOSE);
-        }
-        return true;
-    }
-    override onBindFunction(core: LiveSyncCore, services: typeof core.services): void {
-        super.onBindFunction(core, services);
-        services.appLifecycle.onLayoutReady.addHandler(this._everyOnLayoutReady.bind(this));
-    }
-}

src/modules/coreFeatures/ModuleResolveMismatchedTweaks.ts

@@ -2,9 +2,11 @@ import { Logger, LOG_LEVEL_NOTICE } from "octagonal-wheels/common/logger";
 import { extractObject } from "octagonal-wheels/object";
 import {
     TweakValuesShouldMatchedTemplate,
+    TweakValuesTemplate,
     IncompatibleChanges,
     confName,
     type TweakValues,
+    type ObsidianLiveSyncSettings,
     type RemoteDBSettings,
     IncompatibleChangesInSpecificPattern,
     CompatibleButLossyChanges,
@@ -14,8 +16,107 @@ import { AbstractModule } from "../AbstractModule.ts";
 import { $msg } from "../../lib/src/common/i18n.ts";
 import type { InjectableServiceHub } from "../../lib/src/services/InjectableServices.ts";
 import type { LiveSyncCore } from "../../main.ts";
+import { REMOTE_P2P } from "@lib/common/models/setting.const.ts";
+
+function valueToString(value: any) {
+    if (typeof value === "boolean") {
+        return value ? "true" : "false";
+    }
+    if (typeof value === "object") {
+        return JSON.stringify(value);
+    }
+    return `${value}`;
+}
 
 export class ModuleResolvingMismatchedTweaks extends AbstractModule {
+    private _hasNotifiedAutoAcceptCompatibleUndefined = false;
+
+    private _collectMismatchedTweakKeys(current: TweakValues, preferred: Partial<TweakValues>) {
+        const items = Object.keys(
+            TweakValuesShouldMatchedTemplate
+        ) as (keyof typeof TweakValuesShouldMatchedTemplate)[];
+        return items.filter((key) => current[key] !== preferred[key]);
+    }
+
+    private _selectNewerTweakSide(current: TweakValues, preferred: Partial<TweakValues>): "REMOTE" | "CURRENT" {
+        Logger(`Modified: ${current.tweakModified} (current) vs ${preferred.tweakModified} (preferred)`);
+        const currentModified = current.tweakModified;
+        const preferredModified = preferred.tweakModified;
+        // debugger;
+        const hasCurrentModified = typeof currentModified === "number" && currentModified > 0;
+        const hasPreferredModified = typeof preferredModified === "number" && preferredModified > 0;
+
+        if (!hasCurrentModified && !hasPreferredModified) return "REMOTE";
+        if (!hasCurrentModified) return "REMOTE";
+        if (!hasPreferredModified) return "CURRENT";
+        if (preferredModified >= currentModified) return "REMOTE";
+        return "CURRENT";
+    }
+
+    private async _shouldAutoAcceptCompatibleLossy(
+        current: TweakValues,
+        preferred: Partial<TweakValues>,
+        mismatchedKeys: (keyof typeof TweakValuesShouldMatchedTemplate)[]
+    ): Promise<"REMOTE" | "CURRENT" | undefined> {
+        if (mismatchedKeys.length === 0) return undefined;
+        const hasOnlyCompatibleLossyMismatches = mismatchedKeys.every(
+            (key) => CompatibleButLossyChanges.indexOf(key) !== -1
+        );
+        if (!hasOnlyCompatibleLossyMismatches) return undefined;
+
+        if (this.settings.autoAcceptCompatibleTweak === undefined) {
+            if (this._hasNotifiedAutoAcceptCompatibleUndefined) {
+                return undefined;
+            }
+            this._hasNotifiedAutoAcceptCompatibleUndefined = true;
+            const CHOICE_ENABLE = $msg("TweakMismatchResolve.Action.EnableAutoAcceptCompatible");
+            const CHOICE_DISABLE = $msg("TweakMismatchResolve.Action.DisableAutoAcceptCompatible");
+            const CHOICES = [CHOICE_ENABLE, CHOICE_DISABLE] as const;
+            const message = $msg("TweakMismatchResolve.Message.AutoAcceptCompatibleUndefined");
+            const ret = await this.core.confirm.askSelectStringDialogue(message, CHOICES, {
+                title: $msg("TweakMismatchResolve.Title.AutoAcceptCompatible"),
+                timeout: 0,
+                defaultAction: CHOICE_ENABLE,
+            });
+            if (ret !== CHOICE_ENABLE) {
+                return undefined;
+            }
+            await this.services.setting.applyPartial(
+                {
+                    autoAcceptCompatibleTweak: true,
+                },
+                true
+            );
+            Logger("Auto-accept for compatible tweak mismatch has been enabled.");
+        }
+
+        if (this.settings.autoAcceptCompatibleTweak !== true) return undefined;
+        return this._selectNewerTweakSide(current, preferred);
+    }
+
+    /**
+     * Hook before saving settings, to check if there are changes in tweak values, and if so,
+     * update the tweakModified timestamp to current time.
+     * This allows other devices to know that the tweak values have been changed and decide whether to accept the new values based on the modification time.
+     * @param next
+     * @param previous
+     * @returns
+     */
+    async _onBeforeSaveSettingData(next: ObsidianLiveSyncSettings, previous: ObsidianLiveSyncSettings) {
+        const tweakKeys = Object.keys(TweakValuesTemplate) as (keyof TweakValues)[];
+        const tweakKeysForUpdate = tweakKeys.filter((key) => key !== "tweakModified");
+        const hasChangedTweak = tweakKeysForUpdate.some((key) => next[key] !== previous[key]);
+        if (!hasChangedTweak) return;
+        Logger(
+            `Some tweak values have been changed. ${tweakKeysForUpdate.filter((key) => next[key] !== previous[key]).join(", ")}`
+        );
+        const modified = Date.now();
+        Logger(`Modified: ${modified}`);
+        return await Promise.resolve({
+            tweakModified: modified,
+        });
+    }
+
     async _anyAfterConnectCheckFailed(): Promise<boolean | "CHECKAGAIN" | undefined> {
         if (!this.core.replicator.tweakSettingsMismatched && !this.core.replicator.preferredTweakValue) return false;
         const preferred = this.core.replicator.preferredTweakValue;
@@ -26,10 +127,16 @@ export class ModuleResolvingMismatchedTweaks extends AbstractModule {
         if (ret == "IGNORE") return true;
     }
 
-    async _checkAndAskResolvingMismatchedTweaks(
-        preferred: Partial<TweakValues>
-    ): Promise<[TweakValues | boolean, boolean]> {
-        const mine = extractObject(TweakValuesShouldMatchedTemplate, this.settings);
+    async _checkAndAskResolvingMismatchedTweaks(preferred: TweakValues): Promise<[TweakValues | boolean, boolean]> {
+        const mine = extractObject(TweakValuesTemplate, this.settings) as TweakValues;
+        const mismatchedKeys = this._collectMismatchedTweakKeys(mine, preferred);
+        const autoAcceptSide = await this._shouldAutoAcceptCompatibleLossy(mine, preferred, mismatchedKeys);
+        if (autoAcceptSide === "REMOTE") {
+            return [{ ...mine, ...preferred }, false];
+        }
+        if (autoAcceptSide === "CURRENT") {
+            return [true, false];
+        }
         const items = Object.entries(TweakValuesShouldMatchedTemplate);
         let rebuildRequired = false;
         let rebuildRecommended = false;
@@ -68,8 +175,8 @@ export class ModuleResolvingMismatchedTweaks extends AbstractModule {
             tableRows.push(
                 $msg("TweakMismatchResolve.Table.Row", {
                     name: confName(key),
-                    self: valueMine,
-                    remote: valuePreferred,
+                    self: valueToString(valueMine),
+                    remote: valueToString(valuePreferred),
                 })
             );
         }
@@ -136,9 +243,7 @@ export class ModuleResolvingMismatchedTweaks extends AbstractModule {
         if (!tweaks) {
             return "IGNORE";
         }
-        const preferred = extractObject(TweakValuesShouldMatchedTemplate, tweaks);
-
-        const [conf, rebuildRequired] = await this.services.tweakValue.checkAndAskResolvingMismatched(preferred);
+        const [conf, rebuildRequired] = await this.services.tweakValue.checkAndAskResolvingMismatched(tweaks);
         if (!conf) return "IGNORE";
 
         if (conf === true) {
@@ -146,10 +251,7 @@ export class ModuleResolvingMismatchedTweaks extends AbstractModule {
             if (rebuildRequired) {
                 await this.core.rebuilder.$rebuildRemote();
             }
-            Logger(
-                `Tweak values on the remote server have been updated. Your other device will see this message.`,
-                LOG_LEVEL_NOTICE
-            );
+            Logger($msg("TweakMismatchResolve.Message.remoteUpdated"), LOG_LEVEL_NOTICE);
             return "CHECKAGAIN";
         }
         if (conf) {
@@ -159,7 +261,7 @@ export class ModuleResolvingMismatchedTweaks extends AbstractModule {
             if (rebuildRequired) {
                 await this.core.rebuilder.$fetchLocal();
             }
-            Logger(`Configuration has been updated as configured by the other device.`, LOG_LEVEL_NOTICE);
+            Logger($msg("TweakMismatchResolve.Message.mineUpdated"), LOG_LEVEL_NOTICE);
             return "CHECKAGAIN";
         }
         return "IGNORE";
@@ -186,6 +288,9 @@ export class ModuleResolvingMismatchedTweaks extends AbstractModule {
     async _checkAndAskUseRemoteConfiguration(
         trialSetting: RemoteDBSettings
     ): Promise<{ result: false | TweakValues; requireFetch: boolean }> {
+        if (trialSetting.remoteType === REMOTE_P2P) {
+            return { result: false, requireFetch: false };
+        }
         const preferred = await this.services.tweakValue.fetchRemotePreferred(trialSetting);
         if (preferred) {
             return await this.services.tweakValue.askUseRemoteConfiguration(trialSetting, preferred);
@@ -197,6 +302,16 @@ export class ModuleResolvingMismatchedTweaks extends AbstractModule {
         trialSetting: RemoteDBSettings,
         preferred: TweakValues
     ): Promise<{ result: false | TweakValues; requireFetch: boolean }> {
+        const localTweaks = extractObject(TweakValuesTemplate, this.settings) as TweakValues;
+        const mismatchedKeys = this._collectMismatchedTweakKeys(localTweaks, preferred);
+        const autoAcceptSide = await this._shouldAutoAcceptCompatibleLossy(localTweaks, preferred, mismatchedKeys);
+        if (autoAcceptSide === "REMOTE") {
+            return { result: { ...trialSetting, ...preferred }, requireFetch: false };
+        }
+        if (autoAcceptSide === "CURRENT") {
+            return { result: false, requireFetch: false };
+        }
+
         const items = Object.entries(TweakValuesShouldMatchedTemplate);
         let rebuildRequired = false;
         let rebuildRecommended = false;
@@ -207,8 +322,8 @@ export class ModuleResolvingMismatchedTweaks extends AbstractModule {
         // const items = [mine,preferred]
         for (const v of items) {
             const key = v[0] as keyof typeof TweakValuesShouldMatchedTemplate;
-            const remoteValueForDisplay = escapeMarkdownValue(preferred[key]);
-            const currentValueForDisplay = `${escapeMarkdownValue((trialSetting as TweakValues)?.[key])}`;
+            const remoteValueForDisplay = escapeMarkdownValue(valueToString(preferred[key]));
+            const currentValueForDisplay = escapeMarkdownValue(valueToString((trialSetting as TweakValues)?.[key]));
             if ((trialSetting as TweakValues)?.[key] !== preferred[key]) {
                 if (IncompatibleChanges.indexOf(key) !== -1) {
                     rebuildRequired = true;
@@ -285,6 +400,7 @@ export class ModuleResolvingMismatchedTweaks extends AbstractModule {
     }
 
     override onBindFunction(core: LiveSyncCore, services: InjectableServiceHub): void {
+        services.setting.onBeforeSaveSettingData.addHandler(this._onBeforeSaveSettingData.bind(this));
         services.tweakValue.fetchRemotePreferred.setHandler(this._fetchRemotePreferredTweakValues.bind(this));
         services.tweakValue.checkAndAskResolvingMismatched.setHandler(
             this._checkAndAskResolvingMismatchedTweaks.bind(this)

src/modules/coreFeatures/ModuleResolveMismatchedTweaks.unit.spec.ts

@@ -0,0 +1,108 @@
+import { describe, expect, it, vi } from "vitest";
+import { DEFAULT_SETTINGS, REMOTE_COUCHDB, type RemoteDBSettings, type TweakValues } from "@lib/common/types";
+import { ModuleResolvingMismatchedTweaks } from "./ModuleResolveMismatchedTweaks";
+
+function createModule(settingsOverride: Partial<typeof DEFAULT_SETTINGS> = {}) {
+    const askSelectStringDialogue = vi.fn(async () => undefined);
+    const core = {
+        _services: {
+            API: {
+                addLog: vi.fn(),
+                addCommand: vi.fn(),
+                registerWindow: vi.fn(),
+                addRibbonIcon: vi.fn(),
+                registerProtocolHandler: vi.fn(),
+            },
+            setting: {
+                saveSettingData: vi.fn(async () => undefined),
+            },
+        },
+        settings: {
+            ...DEFAULT_SETTINGS,
+            remoteType: REMOTE_COUCHDB,
+            ...settingsOverride,
+        },
+        confirm: {
+            askSelectStringDialogue,
+        },
+    } as any;
+
+    Object.defineProperty(core, "services", {
+        get() {
+            return core._services;
+        },
+    });
+
+    const module = new ModuleResolvingMismatchedTweaks(core);
+    return { module, core, askSelectStringDialogue };
+}
+
+describe("ModuleResolvingMismatchedTweaks", () => {
+    it("should auto-accept compatible mismatches on connect check using newer remote tweakModified", async () => {
+        const { module, askSelectStringDialogue } = createModule({
+            autoAcceptCompatibleTweak: true,
+            hashAlg: "xxhash64",
+            tweakModified: 100,
+        });
+
+        const preferred = {
+            ...(DEFAULT_SETTINGS as unknown as TweakValues),
+            hashAlg: "xxhash32",
+            tweakModified: 200,
+        } as Partial<TweakValues>;
+
+        const [conf, rebuild] = await module._checkAndAskResolvingMismatchedTweaks(preferred);
+
+        expect(conf).toEqual(preferred);
+        expect(rebuild).toBe(false);
+        expect(askSelectStringDialogue).not.toHaveBeenCalled();
+    });
+
+    it("should fallback to manual confirmation when mismatches are mixed on connect check", async () => {
+        const { module, askSelectStringDialogue } = createModule({
+            autoAcceptCompatibleTweak: true,
+            hashAlg: "xxhash64",
+            encrypt: false,
+            tweakModified: 100,
+        });
+
+        const preferred = {
+            ...(DEFAULT_SETTINGS as unknown as TweakValues),
+            hashAlg: "xxhash32",
+            encrypt: true,
+            tweakModified: 200,
+        } as Partial<TweakValues>;
+
+        const [conf, rebuild] = await module._checkAndAskResolvingMismatchedTweaks(preferred);
+
+        expect(conf).toBe(false);
+        expect(rebuild).toBe(false);
+        expect(askSelectStringDialogue).toHaveBeenCalledTimes(1);
+    });
+
+    it("should auto-accept compatible mismatches on remote-config check using newer local tweakModified", async () => {
+        const { module, askSelectStringDialogue } = createModule({
+            autoAcceptCompatibleTweak: true,
+            hashAlg: "xxhash64",
+            tweakModified: 300,
+        });
+
+        const trialSetting = {
+            ...DEFAULT_SETTINGS,
+            remoteType: REMOTE_COUCHDB,
+            hashAlg: "xxhash64",
+            tweakModified: 300,
+        } as RemoteDBSettings;
+
+        const preferred = {
+            ...(trialSetting as unknown as TweakValues),
+            hashAlg: "xxhash32",
+            tweakModified: 200,
+        } as TweakValues;
+
+        const result = await module._askUseRemoteConfiguration(trialSetting, preferred);
+
+        expect(result).toEqual({ result: false, requireFetch: false });
+        expect(askSelectStringDialogue).not.toHaveBeenCalled();
+    });
+});

src/modules/coreObsidian/UILib/dialogs.ts

@@ -1,9 +1,11 @@
 import { ButtonComponent } from "@/deps.ts";
 import { App, FuzzySuggestModal, MarkdownRenderer, Modal, Plugin, Setting } from "../../../deps.ts";
 import { EVENT_PLUGIN_UNLOADED, eventHub } from "../../../common/events.ts";
+import { compatGlobal, type CompatIntervalHandle } from "@lib/common/coreEnvFunctions.ts";
 
 class AutoClosableModal extends Modal {
     _closeByUnload() {
+        // eslint-disable-next-line @typescript-eslint/unbound-method
         eventHub.off(EVENT_PLUGIN_UNLOADED, this._closeByUnload);
         this.close();
     }
@@ -11,9 +13,11 @@ class AutoClosableModal extends Modal {
     constructor(app: App) {
         super(app);
         this._closeByUnload = this._closeByUnload.bind(this);
+        // eslint-disable-next-line @typescript-eslint/unbound-method
         eventHub.once(EVENT_PLUGIN_UNLOADED, this._closeByUnload);
     }
     override onClose() {
+        // eslint-disable-next-line @typescript-eslint/unbound-method
         eventHub.off(EVENT_PLUGIN_UNLOADED, this._closeByUnload);
     }
 }
@@ -121,7 +125,7 @@ export class PopoverSelectString extends FuzzySuggestModal<string> {
         this.callback = undefined;
     }
     override onClose(): void {
-        setTimeout(() => {
+        compatGlobal.setTimeout(() => {
             if (this.callback) {
                 this.callback("");
                 this.callback = undefined;
@@ -139,7 +143,7 @@ export class MessageBox<T extends readonly string[]> extends AutoClosableModal {
     isManuallyClosed = false;
     defaultAction: string | undefined;
     timeout: number | undefined;
-    timer: ReturnType<typeof setInterval> | undefined = undefined;
+    timer: CompatIntervalHandle | undefined = undefined;
     defaultButtonComponent: ButtonComponent | undefined;
     wideButton: boolean;
 
@@ -165,12 +169,12 @@ export class MessageBox<T extends readonly string[]> extends AutoClosableModal {
         this.timeout = timeout;
         this.wideButton = wideButton;
         if (this.timeout) {
-            this.timer = setInterval(() => {
+            this.timer = compatGlobal.setInterval(() => {
                 if (this.timeout === undefined) return;
                 this.timeout--;
                 if (this.timeout < 0) {
                     if (this.timer) {
-                        clearInterval(this.timer);
+                        compatGlobal.clearInterval(this.timer);
                         this.defaultButtonComponent?.setButtonText(`${defaultAction}`);
                         this.timer = undefined;
                     }
@@ -213,7 +217,7 @@ export class MessageBox<T extends readonly string[]> extends AutoClosableModal {
             if (this.timer) {
                 labelWrapper.empty();
                 labelWrapper.style.display = "none";
-                clearInterval(this.timer);
+                compatGlobal.clearInterval(this.timer);
                 this.timer = undefined;
                 this.defaultButtonComponent?.setButtonText(`${this.defaultAction}`);
             }
@@ -224,7 +228,7 @@ export class MessageBox<T extends readonly string[]> extends AutoClosableModal {
                     this.isManuallyClosed = true;
                     this.result = button;
                     if (this.timer) {
-                        clearInterval(this.timer);
+                        compatGlobal.clearInterval(this.timer);
                         this.timer = undefined;
                     }
                     this.close();
@@ -247,7 +251,7 @@ export class MessageBox<T extends readonly string[]> extends AutoClosableModal {
         const { contentEl } = this;
         contentEl.empty();
         if (this.timer) {
-            clearInterval(this.timer);
+            compatGlobal.clearInterval(this.timer);
             this.timer = undefined;
         }
         if (this.isManuallyClosed) {

src/modules/essential/ModuleInitializerFile.ts

@@ -1,429 +0,0 @@
-import { unique } from "octagonal-wheels/collection";
-import { throttle } from "octagonal-wheels/function";
-import { EVENT_ON_UNRESOLVED_ERROR, eventHub } from "../../common/events.ts";
-import { BASE_IS_NEW, EVEN, isValidPath, TARGET_IS_NEW } from "../../common/utils.ts";
-import {
-    type FilePathWithPrefixLC,
-    type FilePathWithPrefix,
-    type MetaEntry,
-    isMetaEntry,
-    type EntryDoc,
-    LOG_LEVEL_VERBOSE,
-    LOG_LEVEL_NOTICE,
-    LOG_LEVEL_INFO,
-    LOG_LEVEL_DEBUG,
-    type UXFileInfoStub,
-    type LOG_LEVEL,
-} from "../../lib/src/common/types.ts";
-import { isAnyNote } from "../../lib/src/common/utils.ts";
-import { stripAllPrefixes } from "../../lib/src/string_and_binary/path.ts";
-import { AbstractModule } from "../AbstractModule.ts";
-import { withConcurrency } from "octagonal-wheels/iterable/map";
-import type { InjectableServiceHub } from "../../lib/src/services/InjectableServices.ts";
-import type { LiveSyncCore } from "../../main.ts";
-export class ModuleInitializerFile extends AbstractModule {
-    private _detectedErrors = new Set<string>();
-
-    private logDetectedError(message: string, logLevel: LOG_LEVEL = LOG_LEVEL_INFO, key?: string) {
-        this._detectedErrors.add(message);
-        eventHub.emitEvent(EVENT_ON_UNRESOLVED_ERROR);
-        this._log(message, logLevel, key);
-    }
-    private resetDetectedError(message: string) {
-        eventHub.emitEvent(EVENT_ON_UNRESOLVED_ERROR);
-        this._detectedErrors.delete(message);
-    }
-    private async _performFullScan(showingNotice?: boolean, ignoreSuspending: boolean = false): Promise<boolean> {
-        this._log("Opening the key-value database", LOG_LEVEL_VERBOSE);
-        const isInitialized = (await this.core.kvDB.get<boolean>("initialized")) || false;
-        // synchronize all files between database and storage.
-
-        const ERR_NOT_CONFIGURED =
-            "LiveSync is not configured yet. Synchronising between the storage and the local database is now prevented.";
-        if (!this.settings.isConfigured) {
-            this.logDetectedError(ERR_NOT_CONFIGURED, showingNotice ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO, "syncAll");
-            return false;
-        }
-        this.resetDetectedError(ERR_NOT_CONFIGURED);
-
-        const ERR_SUSPENDING =
-            "Now suspending file watching. Synchronising between the storage and the local database is now prevented.";
-        if (!ignoreSuspending && this.settings.suspendFileWatching) {
-            this.logDetectedError(ERR_SUSPENDING, showingNotice ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO, "syncAll");
-            return false;
-        }
-        const MSG_IN_REMEDIATION = `Started in remediation Mode! (Max mtime for reflect events is set). Synchronising between the storage and the local database is now prevented.`;
-        this.resetDetectedError(ERR_SUSPENDING);
-        if (this.settings.maxMTimeForReflectEvents > 0) {
-            this.logDetectedError(MSG_IN_REMEDIATION, LOG_LEVEL_NOTICE, "syncAll");
-            return false;
-        }
-        this.resetDetectedError(MSG_IN_REMEDIATION);
-
-        if (showingNotice) {
-            this._log("Initializing", LOG_LEVEL_NOTICE, "syncAll");
-        }
-        if (isInitialized) {
-            this._log("Restoring storage state", LOG_LEVEL_VERBOSE);
-            await this.core.storageAccess.restoreState();
-        }
-
-        this._log("Initialize and checking database files");
-        this._log("Checking deleted files");
-        await this.collectDeletedFiles();
-
-        this._log("Collecting local files on the storage", LOG_LEVEL_VERBOSE);
-        const filesStorageSrc = await this.core.storageAccess.getFiles();
-
-        const _filesStorage = [] as typeof filesStorageSrc;
-
-        for (const f of filesStorageSrc) {
-            if (await this.services.vault.isTargetFile(f.path)) {
-                _filesStorage.push(f);
-            }
-        }
-
-        const convertCase = <FilePathWithPrefix>(path: FilePathWithPrefix): FilePathWithPrefixLC => {
-            if (this.settings.handleFilenameCaseSensitive) {
-                return path as FilePathWithPrefixLC;
-            }
-            return (path as string).toLowerCase() as FilePathWithPrefixLC;
-        };
-
-        // If handleFilenameCaseSensitive is enabled, `FilePathWithPrefixLC` is the same as `FilePathWithPrefix`.
-
-        const storageFileNameMap = Object.fromEntries(
-            _filesStorage.map((e) => [e.path, e] as [FilePathWithPrefix, UXFileInfoStub])
-        );
-
-        const storageFileNames = Object.keys(storageFileNameMap) as FilePathWithPrefix[];
-
-        const storageFileNameCapsPair = storageFileNames.map(
-            (e) => [e, convertCase(e)] as [FilePathWithPrefix, FilePathWithPrefixLC]
-        );
-
-        // const storageFileNameCS2CI = Object.fromEntries(storageFileNameCapsPair) as Record<FilePathWithPrefix, FilePathWithPrefixLC>;
-        const storageFileNameCI2CS = Object.fromEntries(storageFileNameCapsPair.map((e) => [e[1], e[0]])) as Record<
-            FilePathWithPrefixLC,
-            FilePathWithPrefix
-        >;
-
-        this._log("Collecting local files on the DB", LOG_LEVEL_VERBOSE);
-        const _DBEntries = [] as MetaEntry[];
-        let count = 0;
-        // Fetch all documents from the database (including conflicts to prevent overwriting).
-        for await (const doc of this.localDatabase.findAllNormalDocs({ conflicts: true })) {
-            count++;
-            if (count % 25 == 0)
-                this._log(
-                    `Collecting local files on the DB: ${count}`,
-                    showingNotice ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO,
-                    "syncAll"
-                );
-            const path = this.getPath(doc);
-
-            if (isValidPath(path) && (await this.services.vault.isTargetFile(path))) {
-                if (!isMetaEntry(doc)) {
-                    this._log(`Invalid entry: ${path}`, LOG_LEVEL_INFO);
-                    continue;
-                }
-                _DBEntries.push(doc);
-            }
-        }
-
-        const databaseFileNameMap = Object.fromEntries(
-            _DBEntries.map((e) => [this.getPath(e), e] as [FilePathWithPrefix, MetaEntry])
-        );
-        const databaseFileNames = Object.keys(databaseFileNameMap) as FilePathWithPrefix[];
-        const databaseFileNameCapsPair = databaseFileNames.map(
-            (e) => [e, convertCase(e)] as [FilePathWithPrefix, FilePathWithPrefixLC]
-        );
-        // const databaseFileNameCS2CI = Object.fromEntries(databaseFileNameCapsPair) as Record<FilePathWithPrefix, FilePathWithPrefixLC>;
-        const databaseFileNameCI2CS = Object.fromEntries(databaseFileNameCapsPair.map((e) => [e[1], e[0]])) as Record<
-            FilePathWithPrefix,
-            FilePathWithPrefixLC
-        >;
-
-        const allFiles = unique([
-            ...Object.keys(databaseFileNameCI2CS),
-            ...Object.keys(storageFileNameCI2CS),
-        ]) as FilePathWithPrefixLC[];
-
-        this._log(`Total files in the database: ${databaseFileNames.length}`, LOG_LEVEL_VERBOSE, "syncAll");
-        this._log(`Total files in the storage: ${storageFileNames.length}`, LOG_LEVEL_VERBOSE, "syncAll");
-        this._log(`Total files: ${allFiles.length}`, LOG_LEVEL_VERBOSE, "syncAll");
-        const filesExistOnlyInStorage = allFiles.filter((e) => !databaseFileNameCI2CS[e]);
-        const filesExistOnlyInDatabase = allFiles.filter((e) => !storageFileNameCI2CS[e]);
-        const filesExistBoth = allFiles.filter((e) => databaseFileNameCI2CS[e] && storageFileNameCI2CS[e]);
-
-        this._log(`Files exist only in storage: ${filesExistOnlyInStorage.length}`, LOG_LEVEL_VERBOSE, "syncAll");
-        this._log(`Files exist only in database: ${filesExistOnlyInDatabase.length}`, LOG_LEVEL_VERBOSE, "syncAll");
-        this._log(`Files exist both in storage and database: ${filesExistBoth.length}`, LOG_LEVEL_VERBOSE, "syncAll");
-
-        this._log("Synchronising...");
-        const processStatus = {} as Record<string, string>;
-        const logLevel = showingNotice ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO;
-        const updateLog = throttle((key: string, msg: string) => {
-            processStatus[key] = msg;
-            const log = Object.values(processStatus).join("\n");
-            this._log(log, logLevel, "syncAll");
-        }, 25);
-
-        const initProcess = [];
-        const runAll = async <T>(procedureName: string, objects: T[], callback: (arg: T) => Promise<void>) => {
-            if (objects.length == 0) {
-                this._log(`${procedureName}: Nothing to do`);
-                return;
-            }
-            this._log(procedureName);
-            if (!this.localDatabase.isReady) throw Error("Database is not ready!");
-            let success = 0;
-            let failed = 0;
-            let total = 0;
-            for await (const result of withConcurrency(
-                objects,
-                async (e) => {
-                    try {
-                        await callback(e);
-                        return true;
-                    } catch (ex) {
-                        this._log(`Error while ${procedureName}`, LOG_LEVEL_NOTICE);
-                        this._log(ex, LOG_LEVEL_VERBOSE);
-                        return false;
-                    }
-                },
-                10
-            )) {
-                if (result) {
-                    success++;
-                } else {
-                    failed++;
-                }
-                total++;
-                const msg = `${procedureName}: DONE:${success}, FAILED:${failed}, LAST:${objects.length - total}`;
-                updateLog(procedureName, msg);
-            }
-            const msg = `${procedureName} All done: DONE:${success}, FAILED:${failed}`;
-            updateLog(procedureName, msg);
-        };
-        initProcess.push(
-            runAll("UPDATE DATABASE", filesExistOnlyInStorage, async (e) => {
-                // Exists in storage but not in database.
-                const file = storageFileNameMap[storageFileNameCI2CS[e]];
-                if (!this.services.vault.isFileSizeTooLarge(file.stat.size)) {
-                    const path = file.path;
-                    await this.core.fileHandler.storeFileToDB(file);
-                    // fireAndForget(() => this.checkAndApplySettingFromMarkdown(path, true));
-                    eventHub.emitEvent("event-file-changed", { file: path, automated: true });
-                } else {
-                    this._log(`UPDATE DATABASE: ${e} has been skipped due to file size exceeding the limit`, logLevel);
-                }
-            })
-        );
-        initProcess.push(
-            runAll("UPDATE STORAGE", filesExistOnlyInDatabase, async (e) => {
-                const w = databaseFileNameMap[databaseFileNameCI2CS[e]];
-                // Exists in database but not in storage.
-                const path = this.getPath(w) ?? e;
-                if (w && !(w.deleted || w._deleted)) {
-                    if (!this.services.vault.isFileSizeTooLarge(w.size)) {
-                        // Prevent applying the conflicted state to the storage.
-                        if (w._conflicts?.length ?? 0 > 0) {
-                            this._log(`UPDATE STORAGE: ${path} has conflicts. skipped (x)`, LOG_LEVEL_INFO);
-                            return;
-                        }
-                        // await this.pullFile(path, undefined, false, undefined, false);
-                        // Memo: No need to force
-                        await this.core.fileHandler.dbToStorage(path, null, true);
-                        // fireAndForget(() => this.checkAndApplySettingFromMarkdown(e, true));
-                        eventHub.emitEvent("event-file-changed", {
-                            file: e,
-                            automated: true,
-                        });
-                        this._log(`Check or pull from db:${path} OK`);
-                    } else {
-                        this._log(
-                            `UPDATE STORAGE: ${path} has been skipped due to file size exceeding the limit`,
-                            logLevel
-                        );
-                    }
-                } else if (w) {
-                    this._log(`Deletion history skipped: ${path}`, LOG_LEVEL_VERBOSE);
-                } else {
-                    this._log(`entry not found: ${path}`);
-                }
-            })
-        );
-
-        const fileMap = filesExistBoth.map((path) => {
-            const file = storageFileNameMap[storageFileNameCI2CS[path]];
-            const doc = databaseFileNameMap[databaseFileNameCI2CS[path]];
-            return { file, doc };
-        });
-        initProcess.push(
-            runAll("SYNC DATABASE AND STORAGE", fileMap, async (e) => {
-                const { file, doc } = e;
-                // Prevent applying the conflicted state to the storage.
-                if (doc._conflicts?.length ?? 0 > 0) {
-                    this._log(`SYNC DATABASE AND STORAGE: ${file.path} has conflicts. skipped`, LOG_LEVEL_INFO);
-                    return;
-                }
-                if (
-                    !this.services.vault.isFileSizeTooLarge(file.stat.size) &&
-                    !this.services.vault.isFileSizeTooLarge(doc.size)
-                ) {
-                    await this.syncFileBetweenDBandStorage(file, doc);
-                } else {
-                    this._log(
-                        `SYNC DATABASE AND STORAGE: ${this.getPath(doc)} has been skipped due to file size exceeding the limit`,
-                        logLevel
-                    );
-                }
-            })
-        );
-
-        await Promise.all(initProcess);
-
-        // this.setStatusBarText(`NOW TRACKING!`);
-        this._log("Initialized, NOW TRACKING!");
-        if (!isInitialized) {
-            await this.core.kvDB.set("initialized", true);
-        }
-        if (showingNotice) {
-            this._log("Initialize done!", LOG_LEVEL_NOTICE, "syncAll");
-        }
-        return true;
-    }
-
-    async syncFileBetweenDBandStorage(file: UXFileInfoStub, doc: MetaEntry) {
-        if (!doc) {
-            throw new Error(`Missing doc:${(file as any).path}`);
-        }
-        if ("path" in file) {
-            const w = await this.core.storageAccess.getFileStub((file as any).path);
-            if (w) {
-                file = w;
-            } else {
-                throw new Error(`Missing file:${(file as any).path}`);
-            }
-        }
-
-        const compareResult = this.services.path.compareFileFreshness(file, doc);
-        switch (compareResult) {
-            case BASE_IS_NEW:
-                if (!this.services.vault.isFileSizeTooLarge(file.stat.size)) {
-                    this._log("STORAGE -> DB :" + file.path);
-                    await this.core.fileHandler.storeFileToDB(file);
-                } else {
-                    this._log(
-                        `STORAGE -> DB : ${file.path} has been skipped due to file size exceeding the limit`,
-                        LOG_LEVEL_NOTICE
-                    );
-                }
-                break;
-            case TARGET_IS_NEW:
-                if (!this.services.vault.isFileSizeTooLarge(doc.size)) {
-                    this._log("STORAGE <- DB :" + file.path);
-                    if (await this.core.fileHandler.dbToStorage(doc, stripAllPrefixes(file.path), true)) {
-                        eventHub.emitEvent("event-file-changed", {
-                            file: file.path,
-                            automated: true,
-                        });
-                    } else {
-                        this._log(`STORAGE <- DB : Cloud not read ${file.path}, possibly deleted`, LOG_LEVEL_NOTICE);
-                    }
-                    return caches;
-                } else {
-                    this._log(
-                        `STORAGE <- DB : ${file.path} has been skipped due to file size exceeding the limit`,
-                        LOG_LEVEL_NOTICE
-                    );
-                }
-                break;
-            case EVEN:
-                this._log("STORAGE == DB :" + file.path + "", LOG_LEVEL_DEBUG);
-                break;
-            default:
-                this._log("STORAGE ?? DB :" + file.path + " Something got weird");
-        }
-    }
-
-    // This method uses an old version of database accessor, which is not recommended.
-    // TODO: Fix
-    async collectDeletedFiles() {
-        const limitDays = this.settings.automaticallyDeleteMetadataOfDeletedFiles;
-        if (limitDays <= 0) return;
-        this._log(`Checking expired file history`);
-        const limit = Date.now() - 86400 * 1000 * limitDays;
-        const notes: {
-            path: string;
-            mtime: number;
-            ttl: number;
-            doc: PouchDB.Core.ExistingDocument<EntryDoc & PouchDB.Core.AllDocsMeta>;
-        }[] = [];
-        for await (const doc of this.localDatabase.findAllDocs({ conflicts: true })) {
-            if (isAnyNote(doc)) {
-                if (doc.deleted && doc.mtime - limit < 0) {
-                    notes.push({
-                        path: this.getPath(doc),
-                        mtime: doc.mtime,
-                        ttl: (doc.mtime - limit) / 1000 / 86400,
-                        doc: doc,
-                    });
-                }
-            }
-        }
-        if (notes.length == 0) {
-            this._log("There are no old documents");
-            this._log(`Checking expired file history done`);
-            return;
-        }
-        for (const v of notes) {
-            this._log(`Deletion history expired: ${v.path}`);
-            const delDoc = v.doc;
-            delDoc._deleted = true;
-            await this.localDatabase.putRaw(delDoc);
-        }
-        this._log(`Checking expired file history done`);
-    }
-
-    private async _initializeDatabase(
-        showingNotice: boolean = false,
-        reopenDatabase = true,
-        ignoreSuspending: boolean = false
-    ): Promise<boolean> {
-        this.services.appLifecycle.resetIsReady();
-        if (
-            !reopenDatabase ||
-            (await this.services.database.openDatabase({
-                databaseEvents: this.services.databaseEvents,
-                replicator: this.services.replicator,
-            }))
-        ) {
-            if (this.localDatabase.isReady) {
-                await this.services.vault.scanVault(showingNotice, ignoreSuspending);
-            }
-            const ERR_INITIALISATION_FAILED = `Initializing database has been failed on some module!`;
-            if (!(await this.services.databaseEvents.onDatabaseInitialised(showingNotice))) {
-                this.logDetectedError(ERR_INITIALISATION_FAILED, LOG_LEVEL_NOTICE);
-                return false;
-            }
-            this.resetDetectedError(ERR_INITIALISATION_FAILED);
-            this.services.appLifecycle.markIsReady();
-            // run queued event once.
-            await this.services.fileProcessing.commitPendingFileEvents();
-            return true;
-        } else {
-            this.services.appLifecycle.resetIsReady();
-            return false;
-        }
-    }
-    private _reportDetectedErrors(): Promise<string[]> {
-        return Promise.resolve(Array.from(this._detectedErrors));
-    }
-    override onBindFunction(core: LiveSyncCore, services: InjectableServiceHub): void {
-        services.appLifecycle.getUnresolvedMessages.addHandler(this._reportDetectedErrors.bind(this));
-        services.databaseEvents.initialiseDatabase.addHandler(this._initializeDatabase.bind(this));
-        services.vault.scanVault.addHandler(this._performFullScan.bind(this));
-    }
-}

src/modules/essentialObsidian/APILib/ObsHttpHandler.ts

@@ -27,7 +27,6 @@ export class ObsHttpHandler extends FetchHttpHandler {
         this.requestTimeoutInMs = options === undefined ? undefined : options.requestTimeout;
         this.reverseProxyNoSignUrl = reverseProxyNoSignUrl;
     }
-    // eslint-disable-next-line require-await
     override async handle(
         request: HttpRequest,
         { abortSignal }: HttpHandlerOptions = {}

src/modules/essentialObsidian/ModuleCheckRemoteSize_obsolete.ts

@@ -1,135 +0,0 @@
-import { LOG_LEVEL_INFO, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/logger";
-import { sizeToHumanReadable } from "octagonal-wheels/number";
-import { $msg } from "src/lib/src/common/i18n.ts";
-import type { LiveSyncCore } from "../../main.ts";
-import { EVENT_REQUEST_CHECK_REMOTE_SIZE, eventHub } from "@/common/events.ts";
-import { AbstractModule } from "../AbstractModule.ts";
-
-export class ModuleCheckRemoteSize extends AbstractModule {
-    checkRemoteSize(): Promise<boolean> {
-        this.settings.notifyThresholdOfRemoteStorageSize = 1;
-        return this._allScanStat();
-    }
-
-    private async _allScanStat(): Promise<boolean> {
-        if (this.services.API.isOnline === false) {
-            this._log("Network is offline, skipping remote size check.", LOG_LEVEL_INFO);
-            return true;
-        }
-        this._log($msg("moduleCheckRemoteSize.logCheckingStorageSizes"), LOG_LEVEL_VERBOSE);
-        if (this.settings.notifyThresholdOfRemoteStorageSize < 0) {
-            const message = $msg("moduleCheckRemoteSize.msgSetDBCapacity");
-            const ANSWER_0 = $msg("moduleCheckRemoteSize.optionNoWarn");
-            const ANSWER_800 = $msg("moduleCheckRemoteSize.option800MB");
-            const ANSWER_2000 = $msg("moduleCheckRemoteSize.option2GB");
-            const ASK_ME_NEXT_TIME = $msg("moduleCheckRemoteSize.optionAskMeLater");
-
-            const ret = await this.core.confirm.askSelectStringDialogue(
-                message,
-                [ANSWER_0, ANSWER_800, ANSWER_2000, ASK_ME_NEXT_TIME],
-                {
-                    defaultAction: ASK_ME_NEXT_TIME,
-                    title: $msg("moduleCheckRemoteSize.titleDatabaseSizeNotify"),
-                    timeout: 40,
-                }
-            );
-            if (ret == ANSWER_0) {
-                this.settings.notifyThresholdOfRemoteStorageSize = 0;
-                await this.saveSettings();
-            } else if (ret == ANSWER_800) {
-                this.settings.notifyThresholdOfRemoteStorageSize = 800;
-                await this.saveSettings();
-            } else if (ret == ANSWER_2000) {
-                this.settings.notifyThresholdOfRemoteStorageSize = 2000;
-                await this.saveSettings();
-            }
-        }
-        if (this.settings.notifyThresholdOfRemoteStorageSize > 0) {
-            const remoteStat = await this.core.replicator?.getRemoteStatus(this.settings);
-            if (remoteStat) {
-                const estimatedSize = remoteStat.estimatedSize;
-                if (estimatedSize) {
-                    const maxSize = this.settings.notifyThresholdOfRemoteStorageSize * 1024 * 1024;
-                    if (estimatedSize > maxSize) {
-                        const message = $msg("moduleCheckRemoteSize.msgDatabaseGrowing", {
-                            estimatedSize: sizeToHumanReadable(estimatedSize),
-                            maxSize: sizeToHumanReadable(maxSize),
-                        });
-                        const newMax = ~~(estimatedSize / 1024 / 1024) + 100;
-                        const ANSWER_ENLARGE_LIMIT = $msg("moduleCheckRemoteSize.optionIncreaseLimit", {
-                            newMax: newMax.toString(),
-                        });
-                        const ANSWER_REBUILD = $msg("moduleCheckRemoteSize.optionRebuildAll");
-                        const ANSWER_IGNORE = $msg("moduleCheckRemoteSize.optionDismiss");
-                        const ret = await this.core.confirm.askSelectStringDialogue(
-                            message,
-                            [ANSWER_ENLARGE_LIMIT, ANSWER_REBUILD, ANSWER_IGNORE],
-                            {
-                                defaultAction: ANSWER_IGNORE,
-                                title: $msg("moduleCheckRemoteSize.titleDatabaseSizeLimitExceeded"),
-                                timeout: 60,
-                            }
-                        );
-                        if (ret == ANSWER_REBUILD) {
-                            const ret = await this.core.confirm.askYesNoDialog(
-                                $msg("moduleCheckRemoteSize.msgConfirmRebuild"),
-                                { defaultOption: "No" }
-                            );
-                            if (ret == "yes") {
-                                this.core.settings.notifyThresholdOfRemoteStorageSize = -1;
-                                await this.saveSettings();
-                                await this.core.rebuilder.scheduleRebuild();
-                            }
-                        } else if (ret == ANSWER_ENLARGE_LIMIT) {
-                            this.settings.notifyThresholdOfRemoteStorageSize = ~~(estimatedSize / 1024 / 1024) + 100;
-                            this._log(
-                                $msg("moduleCheckRemoteSize.logThresholdEnlarged", {
-                                    size: this.settings.notifyThresholdOfRemoteStorageSize.toString(),
-                                }),
-                                LOG_LEVEL_NOTICE
-                            );
-                            // await this.core.saveSettings();
-                            await this.core.services.setting.saveSettingData();
-                        } else {
-                            // Dismiss or Close the dialog
-                        }
-
-                        this._log(
-                            $msg("moduleCheckRemoteSize.logExceededWarning", {
-                                measuredSize: sizeToHumanReadable(estimatedSize),
-                                notifySize: sizeToHumanReadable(
-                                    this.settings.notifyThresholdOfRemoteStorageSize * 1024 * 1024
-                                ),
-                            }),
-                            LOG_LEVEL_INFO
-                        );
-                    } else {
-                        this._log(
-                            $msg("moduleCheckRemoteSize.logCurrentStorageSize", {
-                                measuredSize: sizeToHumanReadable(estimatedSize),
-                            }),
-                            LOG_LEVEL_INFO
-                        );
-                    }
-                }
-            }
-        }
-        return true;
-    }
-
-    private _everyOnloadStart(): Promise<boolean> {
-        this.addCommand({
-            id: "livesync-reset-remote-size-threshold-and-check",
-            name: "Reset notification threshold and check the remote database usage",
-            callback: async () => {
-                await this.checkRemoteSize();
-            },
-        });
-        eventHub.onEvent(EVENT_REQUEST_CHECK_REMOTE_SIZE, () => this.checkRemoteSize());
-        return Promise.resolve(true);
-    }
-    override onBindFunction(core: LiveSyncCore, services: typeof core.services): void {
-        services.appLifecycle.onScanningStartupIssues.addHandler(this._allScanStat.bind(this));
-        services.appLifecycle.onInitialise.addHandler(this._everyOnloadStart.bind(this));
-    }
-}

src/modules/essentialObsidian/ModuleObsidianEvents.ts

@@ -13,6 +13,7 @@ import {
     hiddenFilesProcessingCount,
 } from "../../lib/src/mock_and_interop/stores.ts";
 import type { LiveSyncCore } from "../../main.ts";
+import { compatGlobal } from "@lib/common/coreEnvFunctions.ts";
 
 export class ModuleObsidianEvents extends AbstractObsidianModule {
     _everyOnloadStart(): Promise<boolean> {
@@ -79,11 +80,19 @@ export class ModuleObsidianEvents extends AbstractObsidianModule {
         this.watchWindowVisibility = this.watchWindowVisibility.bind(this);
         this.watchWorkspaceOpen = this.watchWorkspaceOpen.bind(this);
         this.watchOnline = this.watchOnline.bind(this);
+        // Already bound
+        // eslint-disable-next-line @typescript-eslint/unbound-method
         this.plugin.registerEvent(this.app.workspace.on("file-open", this.watchWorkspaceOpen));
-        this.plugin.registerDomEvent(document, "visibilitychange", this.watchWindowVisibility);
+        // Already bound
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        this.plugin.registerDomEvent(activeDocument, "visibilitychange", this.watchWindowVisibility);
         this.plugin.registerDomEvent(window, "focus", () => this.setHasFocus(true));
         this.plugin.registerDomEvent(window, "blur", () => this.setHasFocus(false));
+        // Already bound
+        // eslint-disable-next-line @typescript-eslint/unbound-method
         this.plugin.registerDomEvent(window, "online", this.watchOnline);
+        // Already bound
+        // eslint-disable-next-line @typescript-eslint/unbound-method
         this.plugin.registerDomEvent(window, "offline", this.watchOnline);
     }
 
@@ -121,7 +130,7 @@ export class ModuleObsidianEvents extends AbstractObsidianModule {
             return;
         }
 
-        const isHidden = document.hidden;
+        const isHidden = activeWindow.document.hidden;
         if (this.isLastHidden === isHidden) {
             return;
         }
@@ -134,7 +143,7 @@ export class ModuleObsidianEvents extends AbstractObsidianModule {
         } else {
             // suspend all temporary.
             if (this.services.appLifecycle.isSuspended()) return;
-            if (!this.hasFocus) return;
+            // Do not block resume by focus state here; visibility recovery should be enough.
             await this.services.appLifecycle.onResuming();
             await this.services.appLifecycle.onResumed();
         }
@@ -222,9 +231,9 @@ export class ModuleObsidianEvents extends AbstractObsidianModule {
                 );
             });
             this.plugin.registerInterval(
-                setInterval(() => {
+                compatGlobal.setInterval(() => {
                     __tick.value++;
-                }, 1000) as unknown as number
+                }, 1000)
             );
 
             let stableCheck = 3;

src/modules/extras/ModuleDev.ts

@@ -1,17 +1,21 @@
 import { delay, fireAndForget } from "octagonal-wheels/promises";
 import { __onMissingTranslation } from "../../lib/src/common/i18n";
 import { AbstractObsidianModule } from "../AbstractObsidianModule.ts";
-import { LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/logger";
+import { LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE, Logger } from "octagonal-wheels/common/logger";
 import { eventHub } from "../../common/events";
 import { enableTestFunction } from "./devUtil/testUtils.ts";
 import { TestPaneView, VIEW_TYPE_TEST } from "./devUtil/TestPaneView.ts";
 import { writable } from "svelte/store";
-import type { FilePathWithPrefix } from "../../lib/src/common/types.ts";
+import type { CouchDBCredentials, FilePathWithPrefix } from "../../lib/src/common/types.ts";
 import type { LiveSyncCore } from "../../main.ts";
-
+import { getConfiguredFunctionsForEncryption } from "@/lib/src/pouchdb/encryption.ts";
+import { AuthorizationHeaderGenerator } from "@/lib/src/replication/httplib.ts";
+import { fetchChangesForInitialSync } from "@/lib/src/pouchdb/StreamingFetch.ts";
+import { PouchDB } from '@lib/pouchdb/pouchdb-browser.ts';
+import { sizeToHumanReadable } from "octagonal-wheels/number";
 export class ModuleDev extends AbstractObsidianModule {
     _everyOnloadStart(): Promise<boolean> {
-        __onMissingTranslation(() => {});
+        __onMissingTranslation(() => { });
         return Promise.resolve(true);
     }
     async onMissingTranslation(key: string): Promise<void> {
@@ -98,7 +102,75 @@ export class ModuleDev extends AbstractObsidianModule {
         });
         return Promise.resolve(true);
     }
+    async _runBulkCopyTest() {
+        const settings = this.settings;
+        const dummyLocalDatabaseForDrop = new PouchDB("dummy-local");
+        await dummyLocalDatabaseForDrop.destroy();
+        const dummyLocalDatabase = new PouchDB("dummy-local");
+        const replicator = await this.core.services.replicator.getNewReplicator();
+        if (!replicator) {
+            return;
+        }
+        const salt = () => replicator.getReplicationPBKDF2Salt(settings);
+        const enc = getConfiguredFunctionsForEncryption(settings.passphrase,
+            false,
+            false,
+            salt,
+            settings.E2EEAlgorithm,
+        );
+
+        const auth = (
+            settings.useJWT
+                ? {
+                    jwtAlgorithm: settings.jwtAlgorithm,
+                    jwtKey: settings.jwtKey,
+                    jwtExpDuration: settings.jwtExpDuration,
+                    jwtKid: settings.jwtKid,
+                    jwtSub: settings.jwtSub,
+                    type: "jwt",
+                }
+                : {
+                    username: settings.couchDB_USER,
+                    password: settings.couchDB_PASSWORD,
+                    type: "basic",
+                }
+        ) satisfies CouchDBCredentials;
+        const authHeader = await (new AuthorizationHeaderGenerator().getAuthorizationHeader(auth));
+        const remote =
+            settings.couchDB_URI.replace(/\/+$/, "") +
+            (settings.couchDB_DBNAME == "" ? "" : "/" + settings.couchDB_DBNAME);
+        //
+        const ret = fetchChangesForInitialSync(
+            dummyLocalDatabase,
+            remote,
+            authHeader,
+            enc.outgoing,
+            "0",
+            (progress) => {
+                Logger(`Initial sync progress: ${progress.totalValidFetched} / ${progress.docsToFetch}
+Total bytes fetched: ${sizeToHumanReadable(progress.totalBytes)}`,
+                    LOG_LEVEL_NOTICE, "fetch-init-progress"
+                );
+
+            }
+        );
+        await ret;
+
+        const allDocs = await dummyLocalDatabase.allDocs({ include_docs: false });
+        Logger(`Bulk copy test completed. Total documents in local database: ${allDocs.total_rows}`, LOG_LEVEL_NOTICE, "fetch-init-complete");
+        await dummyLocalDatabase.destroy();
+        Logger(`Dummy local database has been destroyed after test.`, LOG_LEVEL_NOTICE);
+    }
     async _everyOnLayoutReady(): Promise<boolean> {
+
+        this.addCommand({
+            "id": "bulk-copy-test",
+            "name": "(DEBUG) Bulk copy test",
+            "callback": async () => {
+                await this._runBulkCopyTest();
+            }
+        })
+
         if (!this.settings.enableDebugTools) return Promise.resolve(true);
         // if (await this.core.storageAccess.isExistsIncludeHidden("_SHOWDIALOGAUTO.md")) {
         //     void this.core.$$showView(VIEW_TYPE_TEST);
@@ -111,7 +183,7 @@ export class ModuleDev extends AbstractObsidianModule {
                 const filename = "test-create-conflict.md";
                 const content = `# Test create conflict\n\n`;
                 const w = await this.core.databaseFileAccess.store({
-                    name: filename as FilePathWithPrefix,
+                    name: filename,
                     path: filename as FilePathWithPrefix,
                     body: new Blob([content], { type: "text/markdown" }),
                     stat: {

src/modules/extras/ModuleIntegratedTest.ts

@@ -1,446 +0,0 @@
-import { delay } from "octagonal-wheels/promises";
-import { LOG_LEVEL_NOTICE, REMOTE_MINIO, type FilePathWithPrefix } from "src/lib/src/common/types";
-import { shareRunningResult } from "octagonal-wheels/concurrency/lock";
-import { AbstractObsidianModule } from "../AbstractObsidianModule";
-
-export class ModuleIntegratedTest extends AbstractObsidianModule {
-    async waitFor(proc: () => Promise<boolean>, timeout = 10000): Promise<boolean> {
-        await delay(100);
-        const start = Date.now();
-        while (!(await proc())) {
-            if (timeout > 0) {
-                if (Date.now() - start > timeout) {
-                    this._log(`Timeout`);
-                    return false;
-                }
-            }
-            await delay(500);
-        }
-        return true;
-    }
-    waitWithReplicating(proc: () => Promise<boolean>, timeout = 10000): Promise<boolean> {
-        return this.waitFor(async () => {
-            await this.tryReplicate();
-            return await proc();
-        }, timeout);
-    }
-    async storageContentIsEqual(file: string, content: string): Promise<boolean> {
-        try {
-            const fileContent = await this.readStorageContent(file as FilePathWithPrefix);
-            if (fileContent === content) {
-                return true;
-            } else {
-                // this._log(`Content is not same \n Expected:${content}\n Actual:${fileContent}`, LOG_LEVEL_VERBOSE);
-                return false;
-            }
-        } catch (e) {
-            this._log(`Error: ${e}`);
-            return false;
-        }
-    }
-    async assert(proc: () => Promise<boolean>): Promise<boolean> {
-        if (!(await proc())) {
-            this._log(`Assertion failed`);
-            return false;
-        }
-        return true;
-    }
-    async __orDie(key: string, proc: () => Promise<boolean>): Promise<true> | never {
-        if (!(await this._test(key, proc))) {
-            throw new Error(`${key}`);
-        }
-        return true;
-    }
-    tryReplicate() {
-        if (!this.settings.liveSync) {
-            return shareRunningResult("replicate-test", async () => {
-                await this.services.replication.replicate();
-            });
-        }
-    }
-    async readStorageContent(file: FilePathWithPrefix): Promise<string | undefined> {
-        if (!(await this.core.storageAccess.isExistsIncludeHidden(file))) {
-            return undefined;
-        }
-        return await this.core.storageAccess.readHiddenFileText(file);
-    }
-    async __proceed(no: number, title: string): Promise<boolean> {
-        const stepFile = "_STEP.md" as FilePathWithPrefix;
-        const stepAckFile = "_STEP_ACK.md" as FilePathWithPrefix;
-        const stepContent = `Step ${no}`;
-        await this.services.conflict.resolveByNewest(stepFile);
-        await this.core.storageAccess.writeFileAuto(stepFile, stepContent);
-        await this.__orDie(`Wait for acknowledge ${no}`, async () => {
-            if (
-                !(await this.waitWithReplicating(async () => {
-                    return await this.storageContentIsEqual(stepAckFile, stepContent);
-                }, 20000))
-            )
-                return false;
-            return true;
-        });
-        return true;
-    }
-    async __join(no: number, title: string): Promise<boolean> {
-        const stepFile = "_STEP.md" as FilePathWithPrefix;
-        const stepAckFile = "_STEP_ACK.md" as FilePathWithPrefix;
-        // const otherStepFile = `_STEP_${isLeader ? "R" : "L"}.md` as FilePathWithPrefix;
-        const stepContent = `Step ${no}`;
-
-        await this.__orDie(`Wait for step ${no} (${title})`, async () => {
-            if (
-                !(await this.waitWithReplicating(async () => {
-                    return await this.storageContentIsEqual(stepFile, stepContent);
-                }, 20000))
-            )
-                return false;
-            return true;
-        });
-        await this.services.conflict.resolveByNewest(stepAckFile);
-        await this.core.storageAccess.writeFileAuto(stepAckFile, stepContent);
-        await this.tryReplicate();
-        return true;
-    }
-
-    async performStep({
-        step,
-        title,
-        isGameChanger,
-        proc,
-        check,
-    }: {
-        step: number;
-        title: string;
-        isGameChanger: boolean;
-        proc: () => Promise<any>;
-        check: () => Promise<boolean>;
-    }): Promise<boolean> {
-        if (isGameChanger) {
-            await this.__proceed(step, title);
-            try {
-                await proc();
-            } catch (e) {
-                this._log(`Error: ${e}`);
-                return false;
-            }
-            return await this.__orDie(`Step ${step} - ${title}`, async () => await this.waitWithReplicating(check));
-        } else {
-            return await this.__join(step, title);
-        }
-    }
-    // // see scenario.md
-    // async testLeader(testMain: (testFileName: FilePathWithPrefix) => Promise<boolean>): Promise<boolean> {
-
-    // }
-    // async testReceiver(testMain: (testFileName: FilePathWithPrefix) => Promise<boolean>): Promise<boolean> {
-
-    // }
-    async nonLiveTestRunner(
-        isLeader: boolean,
-        testMain: (testFileName: FilePathWithPrefix, isLeader: boolean) => Promise<boolean>
-    ): Promise<boolean> {
-        const storage = this.core.storageAccess;
-        // const database = this.core.databaseFileAccess;
-        // const _orDie = this._orDie.bind(this);
-        const testCommandFile = "IT.md" as FilePathWithPrefix;
-        const textCommandResponseFile = "ITx.md" as FilePathWithPrefix;
-        let testFileName: FilePathWithPrefix;
-        this.addTestResult(
-            "-------Starting ... ",
-            true,
-            `Test as ${isLeader ? "Leader" : "Receiver"} command file ${testCommandFile}`
-        );
-        if (isLeader) {
-            await this.__proceed(0, "start");
-        }
-        await this.tryReplicate();
-
-        await this.performStep({
-            step: 0,
-            title: "Make sure that command File Not Exists",
-            isGameChanger: isLeader,
-            proc: async () => await storage.removeHidden(testCommandFile),
-            check: async () => !(await storage.isExistsIncludeHidden(testCommandFile)),
-        });
-        await this.performStep({
-            step: 1,
-            title: "Make sure that command File Not Exists On Receiver",
-            isGameChanger: !isLeader,
-            proc: async () => await storage.removeHidden(textCommandResponseFile),
-            check: async () => !(await storage.isExistsIncludeHidden(textCommandResponseFile)),
-        });
-
-        await this.performStep({
-            step: 2,
-            title: "Decide the test file name",
-            isGameChanger: isLeader,
-            proc: async () => {
-                testFileName = (Date.now() + "-" + Math.ceil(Math.random() * 1000) + ".md") as FilePathWithPrefix;
-                const testCommandFile = "IT.md" as FilePathWithPrefix;
-                await storage.writeFileAuto(testCommandFile, testFileName);
-            },
-            check: () => Promise.resolve(true),
-        });
-        await this.performStep({
-            step: 3,
-            title: "Wait for the command file to be arrived",
-            isGameChanger: !isLeader,
-            proc: async () => {},
-            check: async () => await storage.isExistsIncludeHidden(testCommandFile),
-        });
-
-        await this.performStep({
-            step: 4,
-            title: "Send the response file",
-            isGameChanger: !isLeader,
-            proc: async () => {
-                await storage.writeHiddenFileAuto(textCommandResponseFile, "!");
-            },
-            check: () => Promise.resolve(true),
-        });
-        await this.performStep({
-            step: 5,
-            title: "Wait for the response file to be arrived",
-            isGameChanger: isLeader,
-            proc: async () => {},
-            check: async () => await storage.isExistsIncludeHidden(textCommandResponseFile),
-        });
-
-        await this.performStep({
-            step: 6,
-            title: "Proceed to begin the test",
-            isGameChanger: isLeader,
-            proc: async () => {},
-            check: () => Promise.resolve(true),
-        });
-        await this.performStep({
-            step: 6,
-            title: "Begin the test",
-            isGameChanger: !false,
-            proc: async () => {},
-            check: () => {
-                return Promise.resolve(true);
-            },
-        });
-        // await this.step(0, isLeader, true);
-        try {
-            this.addTestResult("** Main------", true, ``);
-            if (isLeader) {
-                return await testMain(testFileName!, true);
-            } else {
-                const testFileName = await this.readStorageContent(testCommandFile);
-                this.addTestResult("testFileName", true, `Request client to use :${testFileName!}`);
-                return await testMain(testFileName! as FilePathWithPrefix, false);
-            }
-        } finally {
-            this.addTestResult("Teardown", true, `Deleting ${testFileName!}`);
-            await storage.removeHidden(testFileName!);
-        }
-
-        return true;
-        // Make sure the
-    }
-
-    async testBasic(filename: FilePathWithPrefix, isLeader: boolean): Promise<boolean> {
-        const storage = this.core.storageAccess;
-        const database = this.core.databaseFileAccess;
-
-        await this.addTestResult(
-            `---**Starting Basic Test**---`,
-            true,
-            `Test as ${isLeader ? "Leader" : "Receiver"} command file ${filename}`
-        );
-        // if (isLeader) {
-        //     await this._proceed(0);
-        // }
-        // await this.tryReplicate();
-
-        await this.performStep({
-            step: 0,
-            title: "Make sure that file is not exist",
-            isGameChanger: !isLeader,
-            proc: async () => {},
-            check: async () => !(await storage.isExists(filename)),
-        });
-
-        await this.performStep({
-            step: 1,
-            title: "Write a file",
-            isGameChanger: isLeader,
-            proc: async () => await storage.writeFileAuto(filename, "Hello World"),
-            check: async () => await storage.isExists(filename),
-        });
-        await this.performStep({
-            step: 2,
-            title: "Make sure the file is arrived",
-            isGameChanger: !isLeader,
-            proc: async () => {},
-            check: async () => await storage.isExists(filename),
-        });
-        await this.performStep({
-            step: 3,
-            title: "Update to Hello World 2",
-            isGameChanger: isLeader,
-            proc: async () => await storage.writeFileAuto(filename, "Hello World 2"),
-            check: async () => await this.storageContentIsEqual(filename, "Hello World 2"),
-        });
-        await this.performStep({
-            step: 4,
-            title: "Make sure the modified file is arrived",
-            isGameChanger: !isLeader,
-            proc: async () => {},
-            check: async () => await this.storageContentIsEqual(filename, "Hello World 2"),
-        });
-        await this.performStep({
-            step: 5,
-            title: "Update to Hello World 3",
-            isGameChanger: !isLeader,
-            proc: async () => await storage.writeFileAuto(filename, "Hello World 3"),
-            check: async () => await this.storageContentIsEqual(filename, "Hello World 3"),
-        });
-        await this.performStep({
-            step: 6,
-            title: "Make sure the modified file is arrived",
-            isGameChanger: isLeader,
-            proc: async () => {},
-            check: async () => await this.storageContentIsEqual(filename, "Hello World 3"),
-        });
-
-        const multiLineContent = `Line1:A
-Line2:B
-Line3:C
-Line4:D`;
-
-        await this.performStep({
-            step: 7,
-            title: "Update to Multiline",
-            isGameChanger: isLeader,
-            proc: async () => await storage.writeFileAuto(filename, multiLineContent),
-            check: async () => await this.storageContentIsEqual(filename, multiLineContent),
-        });
-
-        await this.performStep({
-            step: 8,
-            title: "Make sure the modified file is arrived",
-            isGameChanger: !isLeader,
-            proc: async () => {},
-            check: async () => await this.storageContentIsEqual(filename, multiLineContent),
-        });
-
-        // While LiveSync, possibly cannot cause the conflict.
-        if (!this.settings.liveSync) {
-            // Step 9 Make Conflict But Resolvable
-            const multiLineContentL = `Line1:A
-Line2:B
-Line3:C!
-Line4:D`;
-            const multiLineContentC = `Line1:A
-Line2:bbbbb
-Line3:C
-Line4:D`;
-
-            await this.performStep({
-                step: 9,
-                title: "Progress to be conflicted",
-                isGameChanger: isLeader,
-                proc: async () => {},
-                check: () => Promise.resolve(true),
-            });
-
-            await storage.writeFileAuto(filename, isLeader ? multiLineContentL : multiLineContentC);
-
-            await this.performStep({
-                step: 10,
-                title: "Update As Conflicted",
-                isGameChanger: !isLeader,
-                proc: async () => {},
-                check: () => Promise.resolve(true),
-            });
-
-            await this.performStep({
-                step: 10,
-                title: "Make sure Automatically resolved",
-                isGameChanger: isLeader,
-                proc: async () => {},
-                check: async () => (await database.getConflictedRevs(filename)).length === 0,
-            });
-            await this.performStep({
-                step: 11,
-                title: "Make sure Automatically resolved",
-                isGameChanger: !isLeader,
-                proc: async () => {},
-                check: async () => (await database.getConflictedRevs(filename)).length === 0,
-            });
-
-            const sensiblyMergedContent = `Line1:A
-Line2:bbbbb
-Line3:C!
-Line4:D`;
-
-            await this.performStep({
-                step: 12,
-                title: "Make sure Sensibly Merged on Leader",
-                isGameChanger: isLeader,
-                proc: async () => {},
-                check: async () => await this.storageContentIsEqual(filename, sensiblyMergedContent),
-            });
-            await this.performStep({
-                step: 13,
-                title: "Make sure Sensibly Merged on Receiver",
-                isGameChanger: !isLeader,
-                proc: async () => {},
-                check: async () => await this.storageContentIsEqual(filename, sensiblyMergedContent),
-            });
-        }
-        await this.performStep({
-            step: 14,
-            title: "Delete File",
-            isGameChanger: isLeader,
-            proc: async () => {
-                await storage.removeHidden(filename);
-            },
-            check: async () => !(await storage.isExists(filename)),
-        });
-
-        await this.performStep({
-            step: 15,
-            title: "Make sure File is deleted",
-            isGameChanger: !isLeader,
-            proc: async () => {},
-            check: async () => !(await storage.isExists(filename)),
-        });
-        this._log(`The Basic Test has been completed`, LOG_LEVEL_NOTICE);
-        return true;
-    }
-
-    async testBasicEvent(isLeader: boolean) {
-        this.settings.liveSync = false;
-        await this.saveSettings();
-        await this._test("basic", async () => await this.nonLiveTestRunner(isLeader, (t, l) => this.testBasic(t, l)));
-    }
-    async testBasicLive(isLeader: boolean) {
-        this.settings.liveSync = true;
-        await this.saveSettings();
-        await this._test("basic", async () => await this.nonLiveTestRunner(isLeader, (t, l) => this.testBasic(t, l)));
-    }
-
-    async _everyModuleTestMultiDevice(): Promise<boolean> {
-        if (!this.settings.enableDebugTools) return Promise.resolve(true);
-        const isLeader = this.core.services.vault.vaultName().indexOf("recv") === -1;
-        this.addTestResult("-------", true, `Test as ${isLeader ? "Leader" : "Receiver"}`);
-        try {
-            this._log(`Starting Test`);
-            await this.testBasicEvent(isLeader);
-            if (this.settings.remoteType == REMOTE_MINIO) await this.testBasicLive(isLeader);
-        } catch (e) {
-            this._log(e);
-            this._log(`Error: ${e}`);
-            return Promise.resolve(false);
-        }
-
-        return Promise.resolve(true);
-    }
-    override onBindFunction(core: typeof this.core, services: typeof core.services): void {
-        services.test.testMultiDevice.addHandler(this._everyModuleTestMultiDevice.bind(this));
-    }
-}

src/modules/extras/ModuleReplicateTest.ts

@@ -1,590 +0,0 @@
-// I intend to discontinue maintenance of this class. It seems preferable to test it externally.
-import { delay } from "octagonal-wheels/promises";
-import { AbstractObsidianModule } from "../AbstractObsidianModule.ts";
-import { LOG_LEVEL_INFO, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/logger";
-import { eventHub } from "../../common/events";
-import { getWebCrypto } from "../../lib/src/mods.ts";
-import { uint8ArrayToHexString } from "octagonal-wheels/binary/hex";
-import { parseYaml, requestUrl, stringifyYaml } from "@/deps.ts";
-import type { FilePath } from "../../lib/src/common/types.ts";
-import { scheduleTask } from "octagonal-wheels/concurrency/task";
-import { getFileRegExp } from "../../lib/src/common/utils.ts";
-import type { LiveSyncCore } from "../../main.ts";
-
-declare global {
-    interface LSEvents {
-        "debug-sync-status": string[];
-    }
-}
-
-export class ModuleReplicateTest extends AbstractObsidianModule {
-    testRootPath = "_test/";
-    testInfoPath = "_testinfo/";
-
-    get isLeader() {
-        return (
-            this.services.vault.getVaultName().indexOf("dev") >= 0 &&
-            this.services.vault.vaultName().indexOf("recv") < 0
-        );
-    }
-
-    get nameByKind() {
-        if (!this.isLeader) {
-            return "RECV";
-        } else if (this.isLeader) {
-            return "LEADER";
-        }
-    }
-    get pairName() {
-        if (this.isLeader) {
-            return "RECV";
-        } else if (!this.isLeader) {
-            return "LEADER";
-        }
-    }
-
-    watchIsSynchronised = false;
-
-    statusBarSyncStatus?: HTMLElement;
-    async readFileContent(file: string) {
-        try {
-            return await this.core.storageAccess.readHiddenFileText(file);
-        } catch {
-            return "";
-        }
-    }
-
-    async dumpList() {
-        if (this.settings.syncInternalFiles) {
-            this._log("Write file list (Include Hidden)");
-            await this.__dumpFileListIncludeHidden("files.md");
-        } else {
-            this._log("Write file list");
-            await this.__dumpFileList("files.md");
-        }
-    }
-    async _everyBeforeReplicate(showMessage: boolean): Promise<boolean> {
-        if (!this.settings.enableDebugTools) return Promise.resolve(true);
-        await this.dumpList();
-        return true;
-    }
-    private _everyOnloadAfterLoadSettings(): Promise<boolean> {
-        if (!this.settings.enableDebugTools) return Promise.resolve(true);
-        this.addCommand({
-            id: "dump-file-structure-normal",
-            name: `Dump Structure (Normal)`,
-            callback: () => {
-                void this.__dumpFileList("files.md").finally(() => {
-                    void this.refreshSyncStatus();
-                });
-            },
-        });
-        this.addCommand({
-            id: "dump-file-structure-ih",
-            name: "Dump Structure (Include Hidden)",
-            callback: () => {
-                const d = "files.md";
-                void this.__dumpFileListIncludeHidden(d);
-            },
-        });
-        this.addCommand({
-            id: "dump-file-structure-auto",
-            name: "Dump Structure",
-            callback: () => {
-                void this.dumpList();
-            },
-        });
-        this.addCommand({
-            id: "dump-file-test",
-            name: `Perform Test (Dev) ${this.isLeader ? "(Leader)" : "(Recv)"}`,
-            callback: () => {
-                void this.performTestManually();
-            },
-        });
-        this.addCommand({
-            id: "watch-sync-result",
-            name: `Watch sync result is matched between devices`,
-            callback: () => {
-                this.watchIsSynchronised = !this.watchIsSynchronised;
-                void this.refreshSyncStatus();
-            },
-        });
-        this.app.vault.on("modify", async (file) => {
-            if (file.path.startsWith(this.testInfoPath)) {
-                await this.refreshSyncStatus();
-            } else {
-                scheduleTask("dumpStatus", 125, async () => {
-                    await this.dumpList();
-                    return true;
-                });
-            }
-        });
-        this.statusBarSyncStatus = this.plugin.addStatusBarItem();
-        return Promise.resolve(true);
-    }
-    async getSyncStatusAsText() {
-        const fileMine = this.testInfoPath + this.nameByKind + "/" + "files.md";
-        const filePair = this.testInfoPath + this.pairName + "/" + "files.md";
-        const mine = parseYaml(await this.readFileContent(fileMine));
-        const pair = parseYaml(await this.readFileContent(filePair));
-        const result = [] as string[];
-        if (mine.length != pair.length) {
-            result.push(`File count is different: ${mine.length} vs ${pair.length}`);
-        }
-        const filesAll = new Set([...mine.map((e: any) => e.path), ...pair.map((e: any) => e.path)]);
-        for (const file of filesAll) {
-            const mineFile = mine.find((e: any) => e.path == file);
-            const pairFile = pair.find((e: any) => e.path == file);
-            if (!mineFile || !pairFile) {
-                result.push(`File not found: ${file}`);
-            } else {
-                if (mineFile.size != pairFile.size) {
-                    result.push(`Size is different: ${file} ${mineFile.size} vs ${pairFile.size}`);
-                }
-                if (mineFile.hash != pairFile.hash) {
-                    result.push(`Hash is different: ${file} ${mineFile.hash} vs ${pairFile.hash}`);
-                }
-            }
-        }
-        eventHub.emitEvent("debug-sync-status", result);
-        return result.join("\n");
-    }
-
-    async refreshSyncStatus() {
-        if (this.watchIsSynchronised) {
-            // Normal Files
-            const syncStatus = await this.getSyncStatusAsText();
-            if (syncStatus) {
-                this.statusBarSyncStatus!.setText(`Sync Status: Having Error`);
-                this._log(`Sync Status: Having Error\n${syncStatus}`, LOG_LEVEL_INFO);
-            } else {
-                this.statusBarSyncStatus!.setText(`Sync Status: Synchronised`);
-            }
-        } else {
-            this.statusBarSyncStatus!.setText("");
-        }
-    }
-
-    async __dumpFileList(outFile?: string) {
-        if (!this.core || !this.core.storageAccess) {
-            this._log("No storage access", LOG_LEVEL_INFO);
-            return;
-        }
-        const files = await this.core.storageAccess.getFiles();
-        const out = [] as any[];
-        const webcrypto = await getWebCrypto();
-        for (const file of files) {
-            if (!(await this.services.vault.isTargetFile(file.path))) {
-                continue;
-            }
-            if (file.path.startsWith(this.testInfoPath)) continue;
-            const stat = await this.core.storageAccess.stat(file.path);
-            if (stat) {
-                const hashSrc = await this.core.storageAccess.readHiddenFileBinary(file.path);
-                const hash = await webcrypto.subtle.digest("SHA-1", hashSrc);
-                const hashStr = uint8ArrayToHexString(new Uint8Array(hash));
-                const item = {
-                    path: file.path,
-                    name: file.name,
-                    size: stat.size,
-                    mtime: stat.mtime,
-                    hash: hashStr,
-                };
-                // const fileLine = `-${file.path}:${stat.size}:${stat.mtime}:${hashStr}`;
-                out.push(item);
-            }
-        }
-        out.sort((a, b) => a.path.localeCompare(b.path));
-        if (outFile) {
-            outFile = this.testInfoPath + this.nameByKind + "/" + outFile;
-            await this.core.storageAccess.ensureDir(outFile);
-            await this.core.storageAccess.writeHiddenFileAuto(outFile, stringifyYaml(out));
-        } else {
-            // console.dir(out);
-        }
-        this._log(`Dumped ${out.length} files`, LOG_LEVEL_INFO);
-    }
-
-    async __dumpFileListIncludeHidden(outFile?: string) {
-        const ignorePatterns = getFileRegExp(this.core.settings, "syncInternalFilesIgnorePatterns");
-        const targetPatterns = getFileRegExp(this.core.settings, "syncInternalFilesTargetPatterns");
-        const out = [] as any[];
-        const files = await this.core.storageAccess.getFilesIncludeHidden("", targetPatterns, ignorePatterns);
-        // console.dir(files);
-        const webcrypto = await getWebCrypto();
-        for (const file of files) {
-            // if (!await this.core.$$isTargetFile(file)) {
-            //     continue;
-            // }
-            if (file.startsWith(this.testInfoPath)) continue;
-            const stat = await this.core.storageAccess.statHidden(file);
-            if (stat) {
-                const hashSrc = await this.core.storageAccess.readHiddenFileBinary(file);
-                const hash = await webcrypto.subtle.digest("SHA-1", hashSrc);
-                const hashStr = uint8ArrayToHexString(new Uint8Array(hash));
-                const item = {
-                    path: file,
-                    name: file.split("/").pop(),
-                    size: stat.size,
-                    mtime: stat.mtime,
-                    hash: hashStr,
-                };
-                // const fileLine = `-${file.path}:${stat.size}:${stat.mtime}:${hashStr}`;
-                out.push(item);
-            }
-        }
-        out.sort((a, b) => a.path.localeCompare(b.path));
-        if (outFile) {
-            outFile = this.testInfoPath + this.nameByKind + "/" + outFile;
-            await this.core.storageAccess.ensureDir(outFile);
-            await this.core.storageAccess.writeHiddenFileAuto(outFile, stringifyYaml(out));
-        } else {
-            // console.dir(out);
-        }
-        this._log(`Dumped ${out.length} files`, LOG_LEVEL_NOTICE);
-    }
-
-    async collectTestFiles() {
-        const remoteTopDir = "https://raw.githubusercontent.com/vrtmrz/obsidian-livesync/refs/heads/main/";
-        const files = [
-            "README.md",
-            "docs/adding_translations.md",
-            "docs/design_docs_of_journalsync.md",
-            "docs/design_docs_of_keep_newborn_chunks.md",
-            "docs/design_docs_of_prefixed_hidden_file_sync.md",
-            "docs/design_docs_of_sharing_tweak_value.md",
-            "docs/quick_setup_cn.md",
-            "docs/quick_setup_ja.md",
-            "docs/quick_setup.md",
-            "docs/settings_ja.md",
-            "docs/settings.md",
-            "docs/setup_cloudant_ja.md",
-            "docs/setup_cloudant.md",
-            "docs/setup_flyio.md",
-            "docs/setup_own_server_cn.md",
-            "docs/setup_own_server_ja.md",
-            "docs/setup_own_server.md",
-            "docs/tech_info_ja.md",
-            "docs/tech_info.md",
-            "docs/terms.md",
-            "docs/troubleshooting.md",
-            "images/1.png",
-            "images/2.png",
-            "images/corrupted_data.png",
-            "images/hatch.png",
-            "images/lock_pattern1.png",
-            "images/lock_pattern2.png",
-            "images/quick_setup_1.png",
-            "images/quick_setup_2.png",
-            "images/quick_setup_3.png",
-            "images/quick_setup_3b.png",
-            "images/quick_setup_4.png",
-            "images/quick_setup_5.png",
-            "images/quick_setup_6.png",
-            "images/quick_setup_7.png",
-            "images/quick_setup_8.png",
-            "images/quick_setup_9_1.png",
-            "images/quick_setup_9_2.png",
-            "images/quick_setup_10.png",
-            "images/remote_db_setting.png",
-            "images/write_logs_into_the_file.png",
-        ];
-        for (const file of files) {
-            const remote = remoteTopDir + file;
-            const local = this.testRootPath + file;
-            try {
-                const f = (await requestUrl(remote)).arrayBuffer;
-                await this.core.storageAccess.ensureDir(local);
-                await this.core.storageAccess.writeHiddenFileAuto(local, f);
-            } catch (ex) {
-                this._log(`Could not fetch ${remote}`, LOG_LEVEL_VERBOSE);
-                this._log(ex, LOG_LEVEL_VERBOSE);
-            }
-        }
-
-        await this.dumpList();
-    }
-
-    async waitFor(proc: () => Promise<boolean>, timeout = 10000): Promise<boolean> {
-        await delay(100);
-        const start = Date.now();
-        while (!(await proc())) {
-            if (timeout > 0) {
-                if (Date.now() - start > timeout) {
-                    this._log(`Timeout`);
-                    return false;
-                }
-            }
-            await delay(500);
-        }
-        return true;
-    }
-
-    async testConflictedManually1() {
-        await this.services.replication.replicate();
-
-        const commonFile = `Resolve! 
-*****, the amazing chocolatier!!`;
-
-        if (this.isLeader) {
-            await this.core.storageAccess.writeHiddenFileAuto(this.testRootPath + "wonka.md", commonFile);
-        }
-
-        await this.services.replication.replicate();
-        await this.services.replication.replicate();
-        if (
-            (await this.core.confirm.askYesNoDialog("Ready to begin the test conflict Manually 1?", {
-                timeout: 30,
-                defaultOption: "Yes",
-            })) == "no"
-        ) {
-            return;
-        }
-
-        const fileA = `Resolve to KEEP THIS
-Willy Wonka, Willy Wonka, the amazing chocolatier!!`;
-
-        const fileB = `Resolve to DISCARD THIS
-Charlie Bucket, Charlie Bucket, the amazing chocolatier!!`;
-
-        if (this.isLeader) {
-            await this.core.storageAccess.writeHiddenFileAuto(this.testRootPath + "wonka.md", fileA);
-        } else {
-            await this.core.storageAccess.writeHiddenFileAuto(this.testRootPath + "wonka.md", fileB);
-        }
-
-        if (
-            (await this.core.confirm.askYesNoDialog("Ready to check the result of Manually 1?", {
-                timeout: 30,
-                defaultOption: "Yes",
-            })) == "no"
-        ) {
-            return;
-        }
-        await this.services.replication.replicate();
-        await this.services.replication.replicate();
-
-        if (
-            !(await this.waitFor(async () => {
-                await this.services.replication.replicate();
-                return (
-                    (await this.__assertStorageContent(
-                        (this.testRootPath + "wonka.md") as FilePath,
-                        fileA,
-                        false,
-                        true
-                    )) == true
-                );
-            }, 30000))
-        ) {
-            return await this.__assertStorageContent((this.testRootPath + "wonka.md") as FilePath, fileA, false, true);
-        }
-        return true;
-        // We have to check the result
-    }
-
-    async testConflictedManually2() {
-        await this.services.replication.replicate();
-
-        const commonFile = `Resolve To concatenate
-ABCDEFG`;
-
-        if (this.isLeader) {
-            await this.core.storageAccess.writeHiddenFileAuto(this.testRootPath + "concat.md", commonFile);
-        }
-
-        await this.services.replication.replicate();
-        await this.services.replication.replicate();
-        if (
-            (await this.core.confirm.askYesNoDialog("Ready to begin the test conflict Manually 2?", {
-                timeout: 30,
-                defaultOption: "Yes",
-            })) == "no"
-        ) {
-            return;
-        }
-
-        const fileA = `Resolve to Concatenate
-ABCDEFGHIJKLMNOPQRSTYZ`;
-
-        const fileB = `Resolve to Concatenate
-AJKLMNOPQRSTUVWXYZ`;
-
-        const concatenated = `Resolve to Concatenate
-ABCDEFGHIJKLMNOPQRSTUVWXYZ`;
-        if (this.isLeader) {
-            await this.core.storageAccess.writeHiddenFileAuto(this.testRootPath + "concat.md", fileA);
-        } else {
-            await this.core.storageAccess.writeHiddenFileAuto(this.testRootPath + "concat.md", fileB);
-        }
-        if (
-            (await this.core.confirm.askYesNoDialog("Ready to test conflict Manually 2?", {
-                timeout: 30,
-                defaultOption: "Yes",
-            })) == "no"
-        ) {
-            return;
-        }
-        await this.services.replication.replicate();
-        await this.services.replication.replicate();
-
-        if (
-            !(await this.waitFor(async () => {
-                await this.services.replication.replicate();
-                return (
-                    (await this.__assertStorageContent(
-                        (this.testRootPath + "concat.md") as FilePath,
-                        concatenated,
-                        false,
-                        true
-                    )) == true
-                );
-            }, 30000))
-        ) {
-            return await this.__assertStorageContent(
-                (this.testRootPath + "concat.md") as FilePath,
-                concatenated,
-                false,
-                true
-            );
-        }
-        return true;
-    }
-
-    async testConflictAutomatic() {
-        if (this.isLeader) {
-            const baseDoc = `Tasks!
-- [ ] Task 1
-- [ ] Task 2
-- [ ] Task 3
-- [ ] Task 4
-`;
-            await this.core.storageAccess.writeHiddenFileAuto(this.testRootPath + "task.md", baseDoc);
-        }
-        await delay(100);
-        await this.services.replication.replicate();
-        await this.services.replication.replicate();
-
-        if (
-            (await this.core.confirm.askYesNoDialog("Ready to test conflict?", {
-                timeout: 30,
-                defaultOption: "Yes",
-            })) == "no"
-        ) {
-            return;
-        }
-        const mod1Doc = `Tasks!
-- [ ] Task 1
-- [v] Task 2
-- [ ] Task 3
-- [ ] Task 4
-`;
-
-        const mod2Doc = `Tasks!
-- [ ] Task 1
-- [ ] Task 2
-- [v] Task 3
-- [ ] Task 4
-`;
-        if (this.isLeader) {
-            await this.core.storageAccess.writeHiddenFileAuto(this.testRootPath + "task.md", mod1Doc);
-        } else {
-            await this.core.storageAccess.writeHiddenFileAuto(this.testRootPath + "task.md", mod2Doc);
-        }
-
-        await this.services.replication.replicate();
-        await this.services.replication.replicate();
-        await delay(1000);
-        if (
-            (await this.core.confirm.askYesNoDialog("Ready to check result?", { timeout: 30, defaultOption: "Yes" })) ==
-            "no"
-        ) {
-            return;
-        }
-        await this.services.replication.replicate();
-        await this.services.replication.replicate();
-        const mergedDoc = `Tasks!
-- [ ] Task 1
-- [v] Task 2
-- [v] Task 3
-- [ ] Task 4
-`;
-        return this.__assertStorageContent((this.testRootPath + "task.md") as FilePath, mergedDoc, false, true);
-    }
-
-    // No longer tested
-    async checkConflictResolution() {
-        this._log("Before testing conflicted files, resolve all once", LOG_LEVEL_NOTICE);
-        await this.services.conflict.resolveAllConflictedFilesByNewerOnes();
-        await this.services.conflict.resolveAllConflictedFilesByNewerOnes();
-        await this.services.replication.replicate();
-        await delay(1000);
-        if (!(await this.testConflictAutomatic())) {
-            this._log("Conflict resolution (Auto) failed", LOG_LEVEL_NOTICE);
-            return false;
-        }
-        if (!(await this.testConflictedManually1())) {
-            this._log("Conflict resolution (Manual1) failed", LOG_LEVEL_NOTICE);
-            return false;
-        }
-        if (!(await this.testConflictedManually2())) {
-            this._log("Conflict resolution (Manual2) failed", LOG_LEVEL_NOTICE);
-            return false;
-        }
-        return true;
-    }
-
-    async __assertStorageContent(
-        fileName: FilePath,
-        content: string,
-        inverted = false,
-        showResult = false
-    ): Promise<boolean | string> {
-        try {
-            const fileContent = await this.core.storageAccess.readHiddenFileText(fileName);
-            let result = fileContent === content;
-            if (inverted) {
-                result = !result;
-            }
-            if (result) {
-                return true;
-            } else {
-                if (showResult) {
-                    this._log(`Content is not same \n Expected:${content}\n Actual:${fileContent}`, LOG_LEVEL_VERBOSE);
-                }
-                return `Content is not same \n Expected:${content}\n Actual:${fileContent}`;
-            }
-        } catch (e) {
-            this._log(`Cannot assert storage content: ${e}`);
-            return false;
-        }
-    }
-    async performTestManually() {
-        if (!this.settings.enableDebugTools) return Promise.resolve(true);
-        await this.checkConflictResolution();
-        // await this.collectTestFiles();
-    }
-
-    // testResults = writable<[boolean, string, string][]>([]);
-    // testResults: string[] = [];
-
-    // $$addTestResult(name: string, key: string, result: boolean, summary?: string, message?: string): void {
-    //     const logLine = `${name}: ${key} ${summary ?? ""}`;
-    //     this.testResults.update((results) => {
-    //         results.push([result, logLine, message ?? ""]);
-    //         return results;
-    //     });
-    // }
-    private async _everyModuleTestMultiDevice(): Promise<boolean> {
-        if (!this.settings.enableDebugTools) return Promise.resolve(true);
-        // this.core.$$addTestResult("DevModule", "Test", true);
-        // return Promise.resolve(true);
-        await this._test("Conflict resolution", async () => await this.checkConflictResolution());
-        return this.testDone();
-    }
-    override onBindFunction(core: LiveSyncCore, services: typeof core.services): void {
-        services.appLifecycle.onSettingLoaded.addHandler(this._everyOnloadAfterLoadSettings.bind(this));
-        services.replication.onBeforeReplicate.addHandler(this._everyBeforeReplicate.bind(this));
-        services.test.testMultiDevice.addHandler(this._everyModuleTestMultiDevice.bind(this));
-    }
-}

src/modules/extras/devUtil/TestPane.svelte

@@ -1,17 +1,15 @@
 <script lang="ts">
-    import { onDestroy, onMount } from "svelte";
+    import { onMount } from "svelte";
     import type ObsidianLiveSyncPlugin from "../../../main.ts";
     import { perf_trench } from "./tests.ts";
     import { MarkdownRenderer, Notice } from "../../../deps.ts";
     import type { ModuleDev } from "../ModuleDev.ts";
     import { fireAndForget } from "octagonal-wheels/promises";
     import { EVENT_LAYOUT_READY, eventHub } from "../../../common/events.ts";
-    import { writable } from "svelte/store";
     export let plugin: ObsidianLiveSyncPlugin;
     export let moduleDev: ModuleDev;
     $: core = plugin.core;
     let performanceTestResult = "";
-    let functionCheckResult = "";
     let testRunning = false;
     let prefTestResultEl: HTMLDivElement;
     let isReady = false;

src/modules/extras/devUtil/TestPaneView.ts

@@ -3,6 +3,11 @@ import TestPaneComponent from "./TestPane.svelte";
 import type ObsidianLiveSyncPlugin from "../../../main.ts";
 import type { ModuleDev } from "../ModuleDev.ts";
 export const VIEW_TYPE_TEST = "ols-pane-test";
+declare global {
+    interface LSEvents {
+        "debug-sync-status": string[];
+    }
+}
 //Log view
 export class TestPaneView extends ItemView {
     component?: TestPaneComponent;

src/modules/features/DocumentHistory/DocumentHistoryModal.ts

@@ -1,6 +1,6 @@
 import { TFile, Modal, App, DIFF_DELETE, DIFF_EQUAL, DIFF_INSERT, diff_match_patch } from "../../../deps.ts";
 import { getPathFromTFile, isValidPath } from "../../../common/utils.ts";
-import { decodeBinary, escapeStringToHTML, readString } from "../../../lib/src/string_and_binary/convert.ts";
+import { decodeBinary, readString } from "../../../lib/src/string_and_binary/convert.ts";
 import ObsidianLiveSyncPlugin from "../../../main.ts";
 import {
     type DocumentID,
@@ -16,6 +16,7 @@ import { fireAndForget, getDocData, readContent } from "../../../lib/src/common/
 import { isPlainText, stripPrefix } from "../../../lib/src/string_and_binary/path.ts";
 import { scheduleOnceIfDuplicated } from "octagonal-wheels/concurrency/lock";
 import type { LiveSyncBaseCore } from "@/LiveSyncBaseCore.ts";
+import { compatGlobal } from "@lib/common/coreEnvFunctions.ts";
 
 function isImage(path: string) {
     const ext = path.split(".").splice(-1)[0].toLowerCase();
@@ -56,6 +57,7 @@ export class DocumentHistoryModal extends Modal {
     info!: HTMLDivElement;
     fileInfo!: HTMLDivElement;
     showDiff = false;
+    diffOnly = false;
     id?: DocumentID;
 
     file: FilePathWithPrefix;
@@ -66,6 +68,20 @@ export class DocumentHistoryModal extends Modal {
     currentDeleted = false;
     initialRev?: string;
 
+    // Diff navigation state
+    currentDiffIndex = -1;
+    diffNavContainer!: HTMLDivElement;
+    diffNavIndicator!: HTMLSpanElement;
+    diffOnlyLabel!: HTMLLabelElement;
+
+    // Search state
+    searchKeyword = "";
+    searchResults: { rev: string; index: number; matchType: "Content" | "Diff" }[] = [];
+    currentSearchIndex = -1;
+    searchResultIndicator!: HTMLSpanElement;
+    searchProgressIndicator!: HTMLSpanElement;
+    searchTimeout: number | null = null;
+
     constructor(
         app: App,
         core: LiveSyncBaseCore,
@@ -83,9 +99,12 @@ export class DocumentHistoryModal extends Modal {
         if (!file && id) {
             this.file = this.services.path.id2path(id);
         }
-        if (localStorage.getItem("ols-history-highlightdiff") == "1") {
+        if (this.app.loadLocalStorage("ols-history-highlightdiff") == "1") {
             this.showDiff = true;
         }
+        if (this.app.loadLocalStorage("ols-history-diffonly") == "1") {
+            this.diffOnly = true;
+        }
     }
 
     async loadFile(initialRev?: string) {
@@ -140,22 +159,97 @@ export class DocumentHistoryModal extends Modal {
         return v;
     }
 
+    prepareContentView(usePreformatted = true) {
+        this.contentView.empty();
+        this.contentView.toggleClass("op-pre", usePreformatted);
+    }
+
+    appendTextDiff(diff: [number, string][]) {
+        let hasOmitted = false;
+        for (const [operation, text] of diff) {
+            if (operation == DIFF_DELETE) {
+                this.appendSearchHighlightedText(this.contentView.createSpan({ cls: "history-deleted" }), text);
+                hasOmitted = false;
+            } else if (operation == DIFF_EQUAL) {
+                if (this.diffOnly) {
+                    if (!hasOmitted) {
+                        this.contentView.appendText("\n...\n");
+                        hasOmitted = true;
+                    }
+                } else {
+                    this.appendSearchHighlightedText(this.contentView.createSpan({ cls: "history-normal" }), text);
+                }
+            } else if (operation == DIFF_INSERT) {
+                this.appendSearchHighlightedText(this.contentView.createSpan({ cls: "history-added" }), text);
+                hasOmitted = false;
+            }
+        }
+    }
+
+    appendSearchHighlightedText(container: HTMLElement, text: string) {
+        if (!this.searchKeyword) {
+            container.appendText(text);
+            return;
+        }
+        const escapedKeyword = this.searchKeyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const regex = new RegExp(escapedKeyword, "gi");
+        let lastIndex = 0;
+        for (const match of text.matchAll(regex)) {
+            const index = match.index ?? 0;
+            if (index > lastIndex) {
+                container.appendText(text.slice(lastIndex, index));
+            }
+            container.createEl("mark", { text: match[0] });
+            lastIndex = index + match[0].length;
+        }
+        if (lastIndex < text.length) {
+            container.appendText(text.slice(lastIndex));
+        }
+    }
+
+    appendImageDiff(baseSrc: string, overlaySrc?: string) {
+        const wrap = this.contentView.createDiv({ cls: "ls-imgdiff-wrap" });
+        const overlay = wrap.createDiv({ cls: "overlay" });
+        overlay.createEl("img", { cls: "img-base" }, (img) => {
+            img.src = baseSrc;
+        });
+        if (overlaySrc) {
+            overlay.createEl("img", { cls: "img-overlay" }, (img) => {
+                img.src = overlaySrc;
+            });
+        }
+    }
+
+    appendDeletedNotice(usePreformatted = true) {
+        const notice = "(At this revision, the file has been deleted)";
+        if (usePreformatted) {
+            this.contentView.appendText(`${notice}\n`);
+        } else {
+            this.contentView.createDiv({ text: notice });
+        }
+    }
+
     async showExactRev(rev: string) {
         const db = this.core.localDatabase;
         const w = await db.getDBEntry(this.file, { rev: rev }, false, false, true);
         this.currentText = "";
         this.currentDeleted = false;
+        this.prepareContentView();
         if (w === false) {
             this.currentDeleted = true;
-            this.info.innerHTML = "";
-            this.contentView.innerHTML = `Could not read this revision<br>(${rev})`;
+            this.info.empty();
+            this.contentView.appendText("Could not read this revision");
+            this.contentView.createEl("br");
+            this.contentView.appendText(`(${rev})`);
         } else {
             this.currentDoc = w;
-            this.info.innerHTML = `Modified:${new Date(w.mtime).toLocaleString()}`;
-            let result = undefined;
+            this.info.setText(`Modified:${new Date(w.mtime).toLocaleString()}`);
             const w1data = readDocument(w);
             this.currentDeleted = !!w.deleted;
-            // this.currentText = w1data;
+            if (typeof w1data == "string") {
+                this.currentText = w1data;
+            }
+            let rendered = false;
             if (this.showDiff) {
                 const prevRevIdx = this.revs_info.length - 1 - ((this.range.value as any) / 1 - 1);
                 if (prevRevIdx >= 0 && prevRevIdx < this.revs_info.length) {
@@ -163,58 +257,228 @@ export class DocumentHistoryModal extends Modal {
                     const w2 = await db.getDBEntry(this.file, { rev: oldRev }, false, false, true);
                     if (w2 != false) {
                         if (typeof w1data == "string") {
-                            result = "";
-                            const dmp = new diff_match_patch();
-                            const w2data = readDocument(w2) as string;
-                            const diff = dmp.diff_main(w2data, w1data);
-                            dmp.diff_cleanupSemantic(diff);
-                            for (const v of diff) {
-                                const x1 = v[0];
-                                const x2 = v[1];
-                                if (x1 == DIFF_DELETE) {
-                                    result += "<span class='history-deleted'>" + escapeStringToHTML(x2) + "</span>";
-                                } else if (x1 == DIFF_EQUAL) {
-                                    result += "<span class='history-normal'>" + escapeStringToHTML(x2) + "</span>";
-                                } else if (x1 == DIFF_INSERT) {
-                                    result += "<span class='history-added'>" + escapeStringToHTML(x2) + "</span>";
+                            const w2data = readDocument(w2);
+                            if (typeof w2data == "string") {
+                                const dmp = new diff_match_patch();
+                                const diff = dmp.diff_main(w2data, w1data);
+                                dmp.diff_cleanupSemantic(diff);
+                                if (this.currentDeleted) {
+                                    this.appendDeletedNotice();
                                 }
+                                this.appendTextDiff(diff);
+                                rendered = true;
                             }
-                            result = result.replace(/\n/g, "<br>");
                         } else if (isImage(this.file)) {
                             const src = this.generateBlobURL("base", w1data);
                             const overlay = this.generateBlobURL(
                                 "overlay",
                                 readDocument(w2) as Uint8Array<ArrayBuffer>
                             );
-                            result = `<div class='ls-imgdiff-wrap'>
-    <div class='overlay'>
-        <img class='img-base' src="${src}">
-        <img class='img-overlay' src='${overlay}'>
-    </div>
-</div>`;
-                            this.contentView.removeClass("op-pre");
+                            this.prepareContentView(false);
+                            if (this.currentDeleted) {
+                                this.appendDeletedNotice(false);
+                            }
+                            this.appendImageDiff(src, overlay);
+                            rendered = true;
                         }
                     }
                 }
             }
-            if (result == undefined) {
+            if (!rendered) {
                 if (typeof w1data != "string") {
                     if (isImage(this.file)) {
                         const src = this.generateBlobURL("base", w1data);
-                        result = `<div class='ls-imgdiff-wrap'>
-<div class='overlay'>
-<img class='img-base' src="${src}">
-</div>
-</div>`;
-                        this.contentView.removeClass("op-pre");
+                        this.prepareContentView(false);
+                        if (this.currentDeleted) {
+                            this.appendDeletedNotice(false);
+                        }
+                        this.appendImageDiff(src);
+                    } else {
+                        if (this.currentDeleted) {
+                            this.appendDeletedNotice();
+                        }
+                        this.contentView.appendText("Binary file");
                     }
                 } else {
-                    result = escapeStringToHTML(w1data);
+                    if (this.currentDeleted) {
+                        this.appendDeletedNotice();
+                    }
+                    this.appendSearchHighlightedText(this.contentView, w1data);
                 }
             }
-            if (result == undefined) result = typeof w1data == "string" ? escapeStringToHTML(w1data) : "Binary file";
-            this.contentView.innerHTML =
-                (this.currentDeleted ? "(At this revision, the file has been deleted)\n" : "") + result;
+        }
+        // Reset diff navigation after content changes
+        this.resetDiffNavigation();
+        if (this.showDiff) {
+            this.navigateDiff("next");
+        } else if (this.searchKeyword) {
+            const firstMark = this.contentView.querySelector("mark");
+            if (firstMark) {
+                firstMark.scrollIntoView({ behavior: "smooth", block: "center" });
+            }
+        }
+    }
+
+    /**
+     * Navigate to the previous or next diff block in the content view.
+     * Only effective when diff highlighting is enabled.
+     */
+    navigateDiff(direction: "prev" | "next") {
+        const diffElements = this.contentView.querySelectorAll(".history-added, .history-deleted");
+        if (diffElements.length === 0) return;
+
+        // Remove previous focus highlight
+        const prevFocused = this.contentView.querySelector(".diff-focused");
+        if (prevFocused) {
+            prevFocused.classList.remove("diff-focused");
+        }
+
+        if (direction === "next") {
+            this.currentDiffIndex = (this.currentDiffIndex + 1) % diffElements.length;
+        } else {
+            this.currentDiffIndex = this.currentDiffIndex <= 0 ? diffElements.length - 1 : this.currentDiffIndex - 1;
+        }
+
+        const target = diffElements[this.currentDiffIndex];
+        target.classList.add("diff-focused");
+        target.scrollIntoView({ behavior: "smooth", block: "center" });
+
+        this.diffNavIndicator.setText(`${this.currentDiffIndex + 1}/${diffElements.length}`);
+    }
+
+    /**
+     * Reset the diff navigation index and update the indicator.
+     */
+    resetDiffNavigation() {
+        this.currentDiffIndex = -1;
+        if (this.diffNavIndicator) {
+            if (this.showDiff) {
+                const diffElements = this.contentView.querySelectorAll(".history-added, .history-deleted");
+                this.diffNavIndicator.setText(diffElements.length > 0 ? `0/${diffElements.length}` : "\u2014");
+            } else {
+                this.diffNavIndicator.setText("\u2014");
+            }
+        }
+        this.updateDiffNavVisibility();
+    }
+
+    /**
+     * Show or hide the diff navigation buttons based on the showDiff state.
+     */
+    updateDiffNavVisibility() {
+        if (this.diffNavContainer) {
+            this.diffNavContainer.style.display = this.showDiff ? "flex" : "none";
+        }
+        if (this.diffOnlyLabel) {
+            this.diffOnlyLabel.style.display = this.showDiff ? "inline-block" : "none";
+        }
+    }
+
+    /**
+     * Search through the last 100 revisions for the given keyword.
+     */
+    async performSearch(keyword: string) {
+        this.searchKeyword = keyword;
+        this.searchResults = [];
+        this.currentSearchIndex = -1;
+
+        if (!keyword) {
+            this.searchResultIndicator.setText("");
+            this.searchProgressIndicator.setText("");
+            return;
+        }
+
+        const db = this.core.localDatabase;
+        const limit = 100;
+        const totalRevs = this.revs_info.length;
+        const end = Math.min(totalRevs, limit);
+
+        this.searchProgressIndicator.setText("Searching...");
+
+        const dmp = new diff_match_patch();
+
+        // 0 is the newest, higher index is older.
+        for (let i = 0; i < end; i++) {
+            const revInfo = this.revs_info[i];
+            const rev = revInfo.rev;
+
+            this.searchProgressIndicator.setText(`Searching ${i + 1}/${end}...`);
+
+            const doc = await db.getDBEntry(this.file, { rev: rev }, false, false, true);
+            if (doc === false) continue;
+
+            const content = readDocument(doc);
+            if (typeof content !== "string") continue;
+
+            const keywordLower = keyword.toLocaleLowerCase();
+
+            // Search in content
+            if (content.toLocaleLowerCase().includes(keywordLower)) {
+                this.searchResults.push({ rev, index: i, matchType: "Content" });
+                this.updateSearchUI();
+                continue;
+            }
+
+            // Search in diff (from older version to this version)
+            // Older version is at i + 1
+            if (i < totalRevs - 1) {
+                const olderRev = this.revs_info[i + 1].rev;
+                const olderDoc = await db.getDBEntry(this.file, { rev: olderRev }, false, false, true);
+                if (olderDoc !== false) {
+                    const olderContent = readDocument(olderDoc);
+                    if (typeof olderContent === "string") {
+                        const diffs = dmp.diff_main(olderContent, content);
+                        let foundInDiff = false;
+                        for (const d of diffs) {
+                            if (
+                                (d[0] === DIFF_INSERT || d[0] === DIFF_DELETE) &&
+                                d[1].toLocaleLowerCase().includes(keywordLower)
+                            ) {
+                                foundInDiff = true;
+                                break;
+                            }
+                        }
+                        if (foundInDiff) {
+                            this.searchResults.push({ rev, index: i, matchType: "Diff" });
+                            this.updateSearchUI();
+                        }
+                    }
+                }
+            }
+        }
+
+        this.searchProgressIndicator.setText("Done");
+        this.updateSearchUI();
+    }
+
+    updateSearchUI() {
+        if (this.searchResults.length === 0) {
+            this.searchResultIndicator.setText(this.searchKeyword ? "No matches found" : "");
+        } else {
+            const current = this.currentSearchIndex >= 0 ? this.currentSearchIndex + 1 : 0;
+            this.searchResultIndicator.setText(`${current}/${this.searchResults.length} matches`);
+        }
+    }
+
+    navigateSearch(direction: "prev" | "next") {
+        if (this.searchResults.length === 0) return;
+
+        if (direction === "next") {
+            this.currentSearchIndex = (this.currentSearchIndex + 1) % this.searchResults.length;
+        } else {
+            this.currentSearchIndex =
+                this.currentSearchIndex <= 0 ? this.searchResults.length - 1 : this.currentSearchIndex - 1;
+        }
+
+        const match = this.searchResults[this.currentSearchIndex];
+        this.range.value = `${this.revs_info.length - 1 - match.index}`;
+        void scheduleOnceIfDuplicated("loadRevs", () => this.loadRevs());
+        this.updateSearchUI();
+
+        // If it's a diff match, make sure Highlight diff is on
+        if (match.matchType === "Diff" && !this.showDiff) {
+            // We could auto-enable it, but maybe just notify the user?
+            // For now, let's just let the user toggle it if they want to see the diff.
         }
     }
 
@@ -224,6 +488,42 @@ export class DocumentHistoryModal extends Modal {
         contentEl.empty();
         this.fileInfo = contentEl.createDiv("");
         this.fileInfo.addClass("op-info");
+
+        // Search Row
+        const searchRow = contentEl.createDiv("");
+        searchRow.addClass("op-info");
+        searchRow.addClass("search-row");
+        searchRow.addClass("history-search-row");
+
+        const searchInput = searchRow.createEl("input", {
+            type: "text",
+            placeholder: "Search in history (last 100)...",
+        });
+        searchInput.addClass("history-search-input");
+        searchInput.addEventListener("input", () => {
+            if (this.searchTimeout) {
+                compatGlobal.clearTimeout(this.searchTimeout);
+            }
+            this.searchTimeout = compatGlobal.setTimeout(() => {
+                void this.performSearch(searchInput.value);
+            }, 500);
+        });
+
+        searchRow.createEl("button", { text: "\u25B2" }, (e) => {
+            e.title = "Previous match";
+            e.addEventListener("click", () => this.navigateSearch("prev"));
+        });
+        searchRow.createEl("button", { text: "\u25BC" }, (e) => {
+            e.title = "Next match";
+            e.addEventListener("click", () => this.navigateSearch("next"));
+        });
+
+        this.searchResultIndicator = searchRow.createEl("span", { text: "" });
+        this.searchResultIndicator.addClass("history-search-result-indicator");
+
+        this.searchProgressIndicator = searchRow.createEl("span", { text: "" });
+        this.searchProgressIndicator.addClass("history-search-progress-indicator");
+
         const divView = contentEl.createDiv("");
         divView.addClass("op-flex");
 
@@ -236,25 +536,66 @@ export class DocumentHistoryModal extends Modal {
                 void scheduleOnceIfDuplicated("loadRevs", () => this.loadRevs());
             });
         });
-        contentEl
-            .createDiv("", (e) => {
-                e.createEl("label", {}, (label) => {
-                    label.appendChild(
-                        createEl("input", { type: "checkbox" }, (checkbox) => {
-                            if (this.showDiff) {
-                                checkbox.checked = true;
-                            }
-                            checkbox.addEventListener("input", (evt: any) => {
-                                this.showDiff = checkbox.checked;
-                                localStorage.setItem("ols-history-highlightdiff", this.showDiff == true ? "1" : "");
-                                void scheduleOnceIfDuplicated("loadRevs", () => this.loadRevs());
-                            });
-                        })
-                    );
-                    label.appendText("Highlight diff");
+        const diffOptionsRow = contentEl.createDiv("");
+        diffOptionsRow.addClass("op-info");
+        diffOptionsRow.addClass("diff-options-row");
+        diffOptionsRow.addClass("history-diff-options-row");
+
+        const highlightDiffContainer = diffOptionsRow.createDiv("");
+        highlightDiffContainer.addClass("history-highlight-diff-container");
+
+        highlightDiffContainer.createEl("label", {}, (label) => {
+            label.addClass("history-highlight-diff-label");
+            label.createEl("input", { type: "checkbox" }, (checkbox) => {
+                if (this.showDiff) {
+                    checkbox.checked = true;
+                }
+                checkbox.addEventListener("input", (evt: any) => {
+                    this.showDiff = checkbox.checked;
+                    this.app.saveLocalStorage("ols-history-highlightdiff", this.showDiff == true ? "1" : null);
+                    this.updateDiffNavVisibility();
+                    void scheduleOnceIfDuplicated("loadRevs", () => this.loadRevs());
                 });
-            })
-            .addClass("op-info");
+            });
+            label.appendText("Highlight diff");
+        });
+
+        const diffOnlyLabel = diffOptionsRow.createEl("label", {});
+        diffOnlyLabel.createEl("input", { type: "checkbox" }, (checkbox) => {
+            if (this.diffOnly) {
+                checkbox.checked = true;
+            }
+            checkbox.addEventListener("input", (evt: any) => {
+                this.diffOnly = checkbox.checked;
+                this.app.saveLocalStorage("ols-history-diffonly", this.diffOnly == true ? "1" : null);
+                void scheduleOnceIfDuplicated("loadRevs", () => this.loadRevs());
+            });
+        });
+        diffOnlyLabel.appendText("Diff only");
+        diffOnlyLabel.addClass("diff-only-label");
+        diffOnlyLabel.style.display = this.showDiff ? "inline-block" : "none";
+        this.diffOnlyLabel = diffOnlyLabel;
+
+        // Diff navigation buttons
+        this.diffNavContainer = diffOptionsRow.createDiv("");
+        this.diffNavContainer.addClass("diff-nav");
+        this.diffNavContainer.style.display = this.showDiff ? "flex" : "none";
+
+        this.diffNavContainer.createEl("button", { text: "\u25B2 Prev" }, (e) => {
+            e.addClass("diff-nav-btn");
+            e.addEventListener("click", () => {
+                this.navigateDiff("prev");
+            });
+        });
+        this.diffNavContainer.createEl("button", { text: "\u25BC Next" }, (e) => {
+            e.addClass("diff-nav-btn");
+            e.addEventListener("click", () => {
+                this.navigateDiff("next");
+            });
+        });
+        this.diffNavIndicator = this.diffNavContainer.createEl("span", { text: "\u2014" });
+        this.diffNavIndicator.addClass("diff-nav-indicator");
+
         this.info = contentEl.createDiv("");
         this.info.addClass("op-info");
         fireAndForget(async () => await this.loadFile(this.initialRev));

src/modules/features/GlobalHistory/GlobalHistory.svelte

@@ -248,7 +248,7 @@
                     </td>
                     <td class="path">
                         <div class="filenames">
-                            <span class="path">/{entry.dirname.split("/").join(`​/`)}</span>
+                            <span class="path">/{entry.dirname.split("/").join(`\u200b/`)}</span>
                             <!-- svelte-ignore a11y-click-events-have-key-events -->
                             <!-- svelte-ignore a11y-no-static-element-interactions -->
                             <!-- svelte-ignore a11y-missing-attribute -->

src/modules/features/InteractiveConflictResolving/ConflictResolveModal.ts

@@ -1,7 +1,6 @@
 import { App, Modal } from "../../../deps.ts";
 import { DIFF_DELETE, DIFF_EQUAL, DIFF_INSERT } from "diff-match-patch";
 import { CANCELLED, LEAVE_TO_SUBSEQUENT, type diff_result } from "../../../lib/src/common/types.ts";
-import { escapeStringToHTML } from "../../../lib/src/string_and_binary/convert.ts";
 import { delay } from "../../../lib/src/common/utils.ts";
 import { eventHub } from "../../../common/events.ts";
 import { globalSlipBoard } from "../../../lib/src/bureau/bureau.ts";
@@ -28,6 +27,9 @@ export class ConflictResolveModal extends Modal {
     localName: string = "Base";
     remoteName: string = "Conflicted";
     offEvent?: ReturnType<typeof eventHub.onEvent>;
+    currentDiffIndex = -1;
+    diffView!: HTMLDivElement;
+    diffNavIndicator!: HTMLSpanElement;
 
     constructor(app: App, filename: string, diff: diff_result, pluginPickMode?: boolean, remoteName?: string) {
         super(app);
@@ -44,6 +46,52 @@ export class ConflictResolveModal extends Modal {
         // sendValue("close-resolve-conflict:" + this.filename, false);
     }
 
+    appendDiffFragment(container: HTMLDivElement, text: string, cls: string) {
+        const lines = text.split("\n");
+        lines.forEach((line, index) => {
+            const span = container.createSpan({ cls });
+            span.setText(line);
+            if (index < lines.length - 1) {
+                container.createSpan({ cls: "ls-mark-cr" });
+                container.createEl("br");
+            }
+        });
+    }
+
+    appendVersionInfo(container: HTMLDivElement, cls: string, name: string, date: string) {
+        const line = container.createSpan({ cls });
+        line.createSpan({ text: name, cls: "conflict-dev-name" });
+        line.appendText(`: ${date}`);
+        container.createEl("br");
+    }
+
+    navigateDiff(direction: "prev" | "next") {
+        const diffElements = this.diffView.querySelectorAll(".added, .deleted");
+        if (diffElements.length === 0) return;
+
+        const prevFocused = this.diffView.querySelector(".diff-focused");
+        if (prevFocused) {
+            prevFocused.classList.remove("diff-focused");
+        }
+
+        if (direction === "next") {
+            this.currentDiffIndex = (this.currentDiffIndex + 1) % diffElements.length;
+        } else {
+            this.currentDiffIndex = this.currentDiffIndex <= 0 ? diffElements.length - 1 : this.currentDiffIndex - 1;
+        }
+
+        const target = diffElements[this.currentDiffIndex];
+        target.classList.add("diff-focused");
+        target.scrollIntoView({ behavior: "smooth", block: "center" });
+        this.diffNavIndicator.setText(`${this.currentDiffIndex + 1}/${diffElements.length}`);
+    }
+
+    resetDiffNavigation() {
+        this.currentDiffIndex = -1;
+        const diffElements = this.diffView.querySelectorAll(".added, .deleted");
+        this.diffNavIndicator.setText(diffElements.length > 0 ? `0/${diffElements.length}` : "\u2014");
+    }
+
     override onOpen() {
         const { contentEl } = this;
         // Send cancel signal for the previous merge dialogue
@@ -60,29 +108,40 @@ export class ConflictResolveModal extends Modal {
         // sendValue("close-resolve-conflict:" + this.filename, false);
         this.titleEl.setText(this.title);
         contentEl.empty();
-        contentEl.createEl("span", { text: this.filename });
-        const div = contentEl.createDiv("");
-        div.addClass("op-scrollable");
-        div.addClass("ls-dialog");
-        let diff = "";
+        const diffOptionsRow = contentEl.createDiv("");
+        diffOptionsRow.addClass("diff-options-row");
+        diffOptionsRow.createEl("span", { text: this.filename });
+
+        const diffNavContainer = diffOptionsRow.createDiv("");
+        diffNavContainer.addClass("diff-nav");
+        diffNavContainer.createEl("button", { text: "\u25B2 Prev" }, (e) => {
+            e.addClass("diff-nav-btn");
+            e.addEventListener("click", () => this.navigateDiff("prev"));
+        });
+        diffNavContainer.createEl("button", { text: "\u25BC Next" }, (e) => {
+            e.addClass("diff-nav-btn");
+            e.addEventListener("click", () => this.navigateDiff("next"));
+        });
+        this.diffNavIndicator = diffNavContainer.createEl("span", { text: "\u2014" });
+        this.diffNavIndicator.addClass("diff-nav-indicator");
+
+        this.diffView = contentEl.createDiv("");
+        this.diffView.addClass("op-scrollable");
+        this.diffView.addClass("ls-dialog");
+        let diffLength = 0;
         for (const v of this.result.diff) {
             const x1 = v[0];
             const x2 = v[1];
+            diffLength += x2.length;
+            if (diffLength > 100 * 1024) {
+                continue;
+            }
             if (x1 == DIFF_DELETE) {
-                diff +=
-                    "<span class='deleted'>" +
-                    escapeStringToHTML(x2).replace(/\n/g, "<span class='ls-mark-cr'></span>\n") +
-                    "</span>";
+                this.appendDiffFragment(this.diffView, x2, "deleted");
             } else if (x1 == DIFF_EQUAL) {
-                diff +=
-                    "<span class='normal'>" +
-                    escapeStringToHTML(x2).replace(/\n/g, "<span class='ls-mark-cr'></span>\n") +
-                    "</span>";
+                this.appendDiffFragment(this.diffView, x2, "normal");
             } else if (x1 == DIFF_INSERT) {
-                diff +=
-                    "<span class='added'>" +
-                    escapeStringToHTML(x2).replace(/\n/g, "<span class='ls-mark-cr'></span>\n") +
-                    "</span>";
+                this.appendDiffFragment(this.diffView, x2, "added");
             }
         }
 
@@ -92,28 +151,32 @@ export class ConflictResolveModal extends Modal {
             new Date(this.result.left.mtime).toLocaleString() + (this.result.left.deleted ? " (Deleted)" : "");
         const date2 =
             new Date(this.result.right.mtime).toLocaleString() + (this.result.right.deleted ? " (Deleted)" : "");
-        div2.innerHTML = `<span class='deleted'><span class='conflict-dev-name'>${this.localName}</span>: ${date1}</span><br>
-<span class='added'><span class='conflict-dev-name'>${this.remoteName}</span>: ${date2}</span><br>`;
-        contentEl.createEl("button", { text: `Use ${this.localName}` }, (e) =>
-            e.addEventListener("click", () => this.sendResponse(this.result.right.rev))
-        ).style.marginRight = "4px";
-        contentEl.createEl("button", { text: `Use ${this.remoteName}` }, (e) =>
-            e.addEventListener("click", () => this.sendResponse(this.result.left.rev))
-        ).style.marginRight = "4px";
+        this.appendVersionInfo(div2, "deleted", this.localName, date1);
+        this.appendVersionInfo(div2, "added", this.remoteName, date2);
+        contentEl.createEl("button", { text: `Use ${this.localName}` }, (e) => {
+            e.addClass("conflict-action-button");
+            e.addEventListener("click", () => this.sendResponse(this.result.right.rev));
+        });
+        contentEl.createEl("button", { text: `Use ${this.remoteName}` }, (e) => {
+            e.addClass("conflict-action-button");
+            e.addEventListener("click", () => this.sendResponse(this.result.left.rev));
+        });
         if (!this.pluginPickMode) {
-            contentEl.createEl("button", { text: "Concat both" }, (e) =>
-                e.addEventListener("click", () => this.sendResponse(LEAVE_TO_SUBSEQUENT))
-            ).style.marginRight = "4px";
+            contentEl.createEl("button", { text: "Concat both" }, (e) => {
+                e.addClass("conflict-action-button");
+                e.addEventListener("click", () => this.sendResponse(LEAVE_TO_SUBSEQUENT));
+            });
         }
-        contentEl.createEl("button", { text: !this.pluginPickMode ? "Not now" : "Cancel" }, (e) =>
-            e.addEventListener("click", () => this.sendResponse(CANCELLED))
-        ).style.marginRight = "4px";
-        diff = diff.replace(/\n/g, "<br>");
-        if (diff.length > 100 * 1024) {
-            div.innerText = "(Too large diff to display)";
-        } else {
-            div.innerHTML = diff;
+        contentEl.createEl("button", { text: !this.pluginPickMode ? "Not now" : "Cancel" }, (e) => {
+            e.addClass("conflict-action-button");
+            e.addEventListener("click", () => this.sendResponse(CANCELLED));
+        });
+        if (diffLength > 100 * 1024) {
+            this.diffView.empty();
+            this.diffView.setText("(Too large diff to display)");
         }
+        this.resetDiffNavigation();
+        this.navigateDiff("next");
     }
 
     sendResponse(result: MergeDialogResult) {

src/modules/features/Log/LogPane.svelte

@@ -1,11 +1,12 @@
 <script lang="ts">
-  import { onDestroy, onMount } from "svelte";
-  import { logMessages } from "../../../lib/src/mock_and_interop/stores";
-  import { reactive, type ReactiveInstance } from "octagonal-wheels/dataobject/reactive";
-  import { Logger } from "../../../lib/src/common/logger";
-  import { $msg as msg, currentLang as lang } from "../../../lib/src/common/i18n.ts";
+    import { onDestroy, onMount } from "svelte";
+    import { logMessages } from "../../../lib/src/mock_and_interop/stores";
+    import { reactive, type ReactiveInstance } from "octagonal-wheels/dataobject/reactive";
+    import { Logger } from "../../../lib/src/common/logger";
+    import { $msg as msg, currentLang as lang } from "../../../lib/src/common/i18n.ts";
+    import { compatGlobal } from "@lib/common/coreEnvFunctions.ts";
 
-  let unsubscribe: () => void;
+    let unsubscribe: () => void;
     let messages = $state([] as string[]);
     let wrapRight = $state(false);
     let autoScroll = $state(true);
@@ -16,90 +17,90 @@
     };
     let { close }: Props = $props();
     // export let close: () => void;
-  function updateLog(logs: ReactiveInstance<string[]>) {
-      const e = logs.value;
-      if (!suspended) {
-          messages = [...e];
-          setTimeout(() => {
-              if (scroll) scroll.scrollTop = scroll.scrollHeight;
-          }, 10);
-      }
-  }
-  onMount(async () => {
-      const _logMessages = reactive(() => logMessages.value);
-      _logMessages.onChanged(updateLog);
-      Logger(msg("logPane.logWindowOpened", {}, lang));
-      unsubscribe = () => _logMessages.offChanged(updateLog);
-  });
-  onDestroy(() => {
-      if (unsubscribe) unsubscribe();
-  });
-  let scroll: HTMLDivElement;
+    function updateLog(logs: ReactiveInstance<string[]>) {
+        const e = logs.value;
+        if (!suspended) {
+            messages = [...e];
+            compatGlobal.setTimeout(() => {
+                if (scroll) scroll.scrollTop = scroll.scrollHeight;
+            }, 10);
+        }
+    }
+    onMount(async () => {
+        const _logMessages = reactive(() => logMessages.value);
+        _logMessages.onChanged(updateLog);
+        Logger(msg("logPane.logWindowOpened", {}, lang));
+        unsubscribe = () => _logMessages.offChanged(updateLog);
+    });
+    onDestroy(() => {
+        if (unsubscribe) unsubscribe();
+    });
+    let scroll: HTMLDivElement;
     function closeDialogue() {
         close();
     }
 </script>
 
 <div class="logpane">
-  <!-- <h1>{msg("logPane.title", {}, lang)}</h1> -->
-  <div class="control">
-      <div class="row">
-          <label>
-              <input type="checkbox" bind:checked={wrapRight} />
-              <span>{msg("logPane.wrap", {}, lang)}</span>
-          </label>
-          <label>
-              <input type="checkbox" bind:checked={autoScroll} />
-              <span>{msg("logPane.autoScroll", {}, lang)}</span>
-          </label>
-          <label>
-              <input type="checkbox" bind:checked={suspended} />
-              <span>{msg("logPane.pause", {}, lang)}</span>
-          </label>
+    <!-- <h1>{msg("logPane.title", {}, lang)}</h1> -->
+    <div class="control">
+        <div class="row">
+            <label>
+                <input type="checkbox" bind:checked={wrapRight} />
+                <span>{msg("logPane.wrap", {}, lang)}</span>
+            </label>
+            <label>
+                <input type="checkbox" bind:checked={autoScroll} />
+                <span>{msg("logPane.autoScroll", {}, lang)}</span>
+            </label>
+            <label>
+                <input type="checkbox" bind:checked={suspended} />
+                <span>{msg("logPane.pause", {}, lang)}</span>
+            </label>
             <span class="spacer"></span>
             <button onclick={() => closeDialogue()}>Close</button>
-      </div>
-  </div>
-  <div class="log" bind:this={scroll}>
-      {#each messages as line}
-          <pre class:wrap-right={wrapRight}>{line}</pre>
-      {/each}
-  </div>
+        </div>
+    </div>
+    <div class="log" bind:this={scroll}>
+        {#each messages as line}
+            <pre class:wrap-right={wrapRight}>{line}</pre>
+        {/each}
+    </div>
 </div>
 
 <style>
-  * {
-      box-sizing: border-box;
-  }
-  .logpane {
-      display: flex;
-      height: 100%;
-      flex-direction: column;
-  }
-  .log {
-      overflow-y: scroll;
-      user-select: text;
+    * {
+        box-sizing: border-box;
+    }
+    .logpane {
+        display: flex;
+        height: 100%;
+        flex-direction: column;
+    }
+    .log {
+        overflow-y: scroll;
+        user-select: text;
         -webkit-user-select: text;
-      padding-bottom: 2em;
-  }
-  .log > pre {
-      margin: 0;
-  }
-  .log > pre.wrap-right {
-      word-break: break-all;
-      max-width: 100%;
-      width: 100%;
-      white-space: normal;
-  }
-  .row {
-      display: flex;
-      flex-direction: row;
-      justify-content: flex-end;
-  }
-  .row > label {
-      display: flex;
-      align-items: center;
-      min-width: 5em;
-      margin-right: 1em;
-  }
+        padding-bottom: 2em;
+    }
+    .log > pre {
+        margin: 0;
+    }
+    .log > pre.wrap-right {
+        word-break: break-all;
+        max-width: 100%;
+        width: 100%;
+        white-space: normal;
+    }
+    .row {
+        display: flex;
+        flex-direction: row;
+        justify-content: flex-end;
+    }
+    .row > label {
+        display: flex;
+        align-items: center;
+        min-width: 5em;
+        margin-right: 1em;
+    }
 </style>

src/modules/features/Log/LogPaneView.ts

@@ -2,7 +2,7 @@ import { WorkspaceLeaf } from "@/deps.ts";
 import LogPaneComponent from "./LogPane.svelte";
 import type ObsidianLiveSyncPlugin from "../../../main.ts";
 import { SvelteItemView } from "../../../common/SvelteItemView.ts";
-import { $msg } from "src/lib/src/common/i18n.ts";
+import { $msg } from "@lib/common/i18n.ts";
 import { mount } from "svelte";
 export const VIEW_TYPE_LOG = "log-log";
 //Log view

src/modules/features/ModuleInteractiveConflictResolver.ts

@@ -88,7 +88,7 @@ export class ModuleInteractiveConflictResolver extends AbstractObsidianModule {
                     return false;
                 }
             } else {
-                this._log(`Merge: Something went wrong: ${filename}, (${toDelete})`, LOG_LEVEL_NOTICE);
+                this._log(`Merge: Something went wrong: ${filename}, (${toDelete as string})`, LOG_LEVEL_NOTICE);
                 return false;
             }
             // In here, some merge has been processed.
@@ -163,7 +163,7 @@ export class ModuleInteractiveConflictResolver extends AbstractObsidianModule {
                 this._log(`There are no conflicting files`, LOG_LEVEL_VERBOSE);
             }
         } catch (e) {
-            this._log(`Error while scanning conflicted files: ${e}`, LOG_LEVEL_NOTICE);
+            this._log(`Error while scanning conflicted files...`, LOG_LEVEL_NOTICE);
             this._log(e, LOG_LEVEL_VERBOSE);
             return false;
         }

src/modules/features/ModuleLog.ts

@@ -25,11 +25,11 @@ import {
     EVENT_ON_UNRESOLVED_ERROR,
 } from "../../common/events.ts";
 import { AbstractObsidianModule } from "../AbstractObsidianModule.ts";
-import { addIcon, normalizePath, Notice } from "../../deps.ts";
+import { addIcon, debounce, normalizePath, Notice, stringifyYaml, type WorkspaceLeaf } from "../../deps.ts";
 import { LOG_LEVEL_NOTICE, setGlobalLogFunction } from "octagonal-wheels/common/logger";
 import { LogPaneView, VIEW_TYPE_LOG } from "./Log/LogPaneView.ts";
 import { serialized } from "octagonal-wheels/concurrency/lock";
-import { $msg } from "src/lib/src/common/i18n.ts";
+import { $msg } from "@lib/common/i18n.ts";
 import { P2PLogCollector } from "@/lib/src/replication/trystero/P2PLogCollector.ts";
 import type { LiveSyncCore } from "../../main.ts";
 import { LiveSyncError } from "@lib/common/LSError.ts";
@@ -41,6 +41,8 @@ import {
 } from "@lib/string_and_binary/path.ts";
 import { MARK_LOG_NETWORK_ERROR, MARK_LOG_SEPARATOR } from "@lib/services/lib/logUtils.ts";
 import { NetworkWarningStyles } from "@lib/common/models/setting.const.ts";
+import { compatGlobal } from "@lib/common/coreEnvFunctions.ts";
+import { generateReport } from "@/common/reportTool.ts";
 
 // This module cannot be a core module because it depends on the Obsidian UI.
 
@@ -50,18 +52,51 @@ const globalLogFunction = (message: any, level?: number, key?: string) => {
     const messageX =
         message instanceof Error
             ? new LiveSyncError("[Error Logged]: " + message.message, { cause: message })
-            : message;
+            : typeof message === "string"
+              ? message
+              : JSON.stringify(message);
     const entry = { message: messageX, level, key } as LogEntry;
     recentLogEntries.value = [...recentLogEntries.value, entry];
 };
 
 setGlobalLogFunction(globalLogFunction);
-let recentLogs = [] as string[];
+// Keep the recent logs in memory for display, but also keep a longer history in logForDump for when the user wants to see more logs.
+// logForDump is not reactive and is only used for dumping logs when requested, while recentLogs is reactive and is used for displaying logs in the UI.
+const logForDump = [] as string[];
 
 function addLog(log: string) {
-    recentLogs = [...recentLogs, log].splice(-200);
-    logMessages.value = recentLogs;
+    logForDump.push(log);
+    while (logForDump.length > 1000) {
+        logForDump.shift();
+    }
 }
+
+// Display log is kept separate from the full log history to optimize performance and memory usage.
+// And debounce the updates to the display log to avoid excessive UI updates when there are many log entries in a short time.
+const logForDisplay = [] as string[];
+
+const updateLogMessage = debounce(() => {
+    logMessages.value = [...logForDisplay];
+}, 25);
+function addDisplayLog(log: string) {
+    logForDisplay.push(log);
+    while (logForDisplay.length > 200) {
+        logForDisplay.shift();
+    }
+    updateLogMessage();
+}
+
+const redactPatterns = [/PBKDF2 salt \(Security Seed\):.*$/];
+function redactLog(log: string) {
+    let redactedLog = log;
+    for (const pattern of redactPatterns) {
+        redactedLog = redactedLog.replace(pattern, (match) => {
+            return match.split(":")[0] + ": [REDACTED]";
+        });
+    }
+    return redactedLog;
+}
+
 // logStore.intercept(e => e.slice(Math.min(e.length - 200, 0)));
 
 const showDebugLog = false;
@@ -86,15 +121,15 @@ export class ModuleLog extends AbstractObsidianModule {
         // const emptyMark = `\u{2003}`;
         function padLeftSpComputed(numI: ReactiveValue<number>, mark: string) {
             const formatted = reactiveSource("");
-            let timer: ReturnType<typeof setTimeout> | undefined = undefined;
+            let timer: number | undefined = undefined;
             let maxLen = 1;
             numI.onChanged((numX) => {
                 const num = numX.value;
                 const numLen = `${Math.abs(num)}`.length + 1;
                 maxLen = maxLen < numLen ? numLen : maxLen;
-                if (timer) clearTimeout(timer);
+                if (timer) compatGlobal.clearTimeout(timer);
                 if (num == 0) {
-                    timer = setTimeout(() => {
+                    timer = compatGlobal.setTimeout(() => {
                         formatted.value = "";
                         maxLen = 1;
                     }, 3000);
@@ -323,7 +358,7 @@ export class ModuleLog extends AbstractObsidianModule {
         if (this.nextFrameQueue) {
             return;
         }
-        this.nextFrameQueue = requestAnimationFrame(() => {
+        this.nextFrameQueue = compatGlobal.requestAnimationFrame(() => {
             this.nextFrameQueue = undefined;
             const { message, status } = this.statusBarLabels.value;
             // const recent = logMessages.value;
@@ -346,7 +381,8 @@ export class ModuleLog extends AbstractObsidianModule {
                         (a, b) => (a < b.ttl ? a : b.ttl),
                         Number.MAX_SAFE_INTEGER
                     );
-                    if (this.logLines.length > 0) setTimeout(() => this.applyStatusBarText(), minimumNext - now);
+                    if (this.logLines.length > 0)
+                        compatGlobal.setTimeout(() => this.applyStatusBarText(), minimumNext - now);
                     const recent = this.logLines.map((e) => e.message);
                     const recentLogs = recent.reverse().join("\n");
                     if (isDirty("recentLogs", recentLogs)) this.logHistory!.innerText = recentLogs;
@@ -368,7 +404,7 @@ export class ModuleLog extends AbstractObsidianModule {
         if (this.statusDiv) {
             this.statusDiv.remove();
         }
-        document.querySelectorAll(`.livesync-status`)?.forEach((e) => e.remove());
+        compatGlobal.document.querySelectorAll(`.livesync-status`)?.forEach((e) => e.remove());
         return Promise.resolve(true);
     }
     _everyOnloadStart(): Promise<boolean> {
@@ -390,7 +426,28 @@ export class ModuleLog extends AbstractObsidianModule {
                 void this.services.API.showWindow(VIEW_TYPE_LOG);
             },
         });
-        this.registerView(VIEW_TYPE_LOG, (leaf) => new LogPaneView(leaf, this.plugin));
+        this.addCommand({
+            id: "dump-debug-info",
+            name: "Generate full report for opening the issue with debug info",
+            callback: async () => {
+                const recentLog = [...logForDump];
+                const report = await generateReport(this.services.setting.currentSettings(), this.core);
+                const info = {
+                    ...report,
+                    recentLog: recentLog.map(redactLog),
+                };
+                const yaml = `\`\`\`\`
+# ---- Debug Info Dump ----
+${stringifyYaml(info)}
+\`\`\`\``;
+                if (await this.services.UI.promptCopyToClipboard("Debug info", yaml)) {
+                    new Notice(
+                        "Debug info copied to clipboard. You can paste it in the issue. Be careful as it may contain sensitive information, review it before sharing."
+                    );
+                }
+            },
+        });
+        this.registerView(VIEW_TYPE_LOG, (leaf: WorkspaceLeaf) => new LogPaneView(leaf, this.plugin));
         return Promise.resolve(true);
     }
     private _everyOnloadAfterLoadSettings(): Promise<boolean> {
@@ -404,7 +461,7 @@ export class ModuleLog extends AbstractObsidianModule {
             void this.setFileStatus();
         });
 
-        const w = document.querySelectorAll(`.livesync-status`);
+        const w = compatGlobal.document.querySelectorAll(`.livesync-status`);
         w.forEach((e) => e.remove());
 
         this.observeForLogs();
@@ -421,6 +478,8 @@ export class ModuleLog extends AbstractObsidianModule {
             this.statusBar?.addClass("syncstatusbar");
         }
         this.adjustStatusDivPosition();
+        this._log("Log module loaded", LOG_LEVEL_INFO);
+        this._log("Verbose log", LOG_LEVEL_VERBOSE);
         return Promise.resolve(true);
     }
 
@@ -444,11 +503,12 @@ export class ModuleLog extends AbstractObsidianModule {
         if (level == LOG_LEVEL_DEBUG && !showDebugLog) {
             return;
         }
+        let memoOnly = false;
         if (level <= LOG_LEVEL_INFO && this.settings && this.settings.lessInformationInLog) {
-            return;
+            memoOnly = true;
         }
         if (this.settings && !this.settings.showVerboseLog && level == LOG_LEVEL_VERBOSE) {
-            return;
+            memoOnly = true;
         }
         const vaultName = this.services.vault.getVaultName();
         const now = new Date();
@@ -456,7 +516,12 @@ export class ModuleLog extends AbstractObsidianModule {
         let errorInfo = "";
         if (message instanceof Error) {
             if (message instanceof LiveSyncError) {
-                errorInfo = `${message.cause?.name}:${message.cause?.message}\n[StackTrace]: ${message.stack}\n[CausedBy]: ${message.cause?.stack}`;
+                if (message.cause && message.cause instanceof Error) {
+                    const causedError = message.cause;
+                    errorInfo = `${causedError?.name}:${causedError?.message}\n[StackTrace]: ${message.stack}\n[CausedBy]: ${causedError?.stack}`;
+                } else {
+                    errorInfo = `${message.name}:${message.message}\n[StackTrace]: ${message.stack}`;
+                }
             } else {
                 const thisStack = new Error().stack;
                 errorInfo = `${message.name}:${message.message}\n[StackTrace]: ${message.stack}\n[LogCallStack]: ${thisStack}`;
@@ -469,6 +534,15 @@ export class ModuleLog extends AbstractObsidianModule {
                   ? `${errorInfo}`
                   : JSON.stringify(message, null, 2);
         const newMessage = timestamp + "->" + messageContent;
+
+        if (this.settings?.writeLogToTheFile) {
+            this.writeLogToTheFile(now, vaultName, newMessage);
+        }
+        addLog(newMessage);
+        if (memoOnly) {
+            return;
+        }
+        addDisplayLog(newMessage);
         if (message instanceof Error) {
             console.error(vaultName + ":" + newMessage);
         } else if (level >= LOG_LEVEL_INFO) {
@@ -479,10 +553,6 @@ export class ModuleLog extends AbstractObsidianModule {
         if (!this.settings?.showOnlyIconsOnEditor) {
             this.statusLog.value = messageContent;
         }
-        if (this.settings?.writeLogToTheFile) {
-            this.writeLogToTheFile(now, vaultName, newMessage);
-        }
-        addLog(newMessage);
         this.logLines.push({ ttl: now.getTime() + 3000, message: newMessage });
 
         if (level >= LOG_LEVEL_NOTICE) {

src/modules/features/ModuleSetupObsidian.ts

@@ -1,208 +0,0 @@
-import { type ObsidianLiveSyncSettings, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "../../lib/src/common/types.ts";
-import { configURIBase } from "../../common/types.ts";
-// import { PouchDB } from "../../lib/src/pouchdb/pouchdb-browser.js";
-import { fireAndForget } from "../../lib/src/common/utils.ts";
-import {
-    EVENT_REQUEST_COPY_SETUP_URI,
-    EVENT_REQUEST_OPEN_P2P_SETTINGS,
-    EVENT_REQUEST_OPEN_SETUP_URI,
-    EVENT_REQUEST_SHOW_SETUP_QR,
-    eventHub,
-} from "../../common/events.ts";
-import { $msg } from "../../lib/src/common/i18n.ts";
-// import { performDoctorConsultation, RebuildOptions } from "@/lib/src/common/configForDoc.ts";
-import type { LiveSyncCore } from "../../main.ts";
-import {
-    encodeQR,
-    encodeSettingsToQRCodeData,
-    encodeSettingsToSetupURI,
-    OutputFormat,
-} from "../../lib/src/API/processSetting.ts";
-import { SetupManager, UserMode } from "./SetupManager.ts";
-import { AbstractModule } from "../AbstractModule.ts";
-
-export class ModuleSetupObsidian extends AbstractModule {
-    private _setupManager!: SetupManager;
-    private _everyOnload(): Promise<boolean> {
-        this._setupManager = this.core.getModule(SetupManager);
-        try {
-            this.registerObsidianProtocolHandler("setuplivesync", async (conf: any) => {
-                if (conf.settings) {
-                    await this._setupManager.onUseSetupURI(
-                        UserMode.Unknown,
-                        `${configURIBase}${encodeURIComponent(conf.settings)}`
-                    );
-                } else if (conf.settingsQR) {
-                    await this._setupManager.decodeQR(conf.settingsQR);
-                }
-            });
-        } catch (e) {
-            this._log(
-                "Failed to register protocol handler. This feature may not work in some environments.",
-                LOG_LEVEL_NOTICE
-            );
-            this._log(e, LOG_LEVEL_VERBOSE);
-        }
-        this.addCommand({
-            id: "livesync-setting-qr",
-            name: "Show settings as a QR code",
-            callback: () => fireAndForget(this.encodeQR()),
-        });
-
-        this.addCommand({
-            id: "livesync-copysetupuri",
-            name: "Copy settings as a new setup URI",
-            callback: () => fireAndForget(this.command_copySetupURI()),
-        });
-        this.addCommand({
-            id: "livesync-copysetupuri-short",
-            name: "Copy settings as a new setup URI (With customization sync)",
-            callback: () => fireAndForget(this.command_copySetupURIWithSync()),
-        });
-
-        this.addCommand({
-            id: "livesync-copysetupurifull",
-            name: "Copy settings as a new setup URI (Full)",
-            callback: () => fireAndForget(this.command_copySetupURIFull()),
-        });
-
-        this.addCommand({
-            id: "livesync-opensetupuri",
-            name: "Use the copied setup URI (Formerly Open setup URI)",
-            callback: () => fireAndForget(this.command_openSetupURI()),
-        });
-
-        eventHub.onEvent(EVENT_REQUEST_OPEN_SETUP_URI, () => fireAndForget(() => this.command_openSetupURI()));
-        eventHub.onEvent(EVENT_REQUEST_COPY_SETUP_URI, () => fireAndForget(() => this.command_copySetupURI()));
-        eventHub.onEvent(EVENT_REQUEST_SHOW_SETUP_QR, () => fireAndForget(() => this.encodeQR()));
-        eventHub.onEvent(EVENT_REQUEST_OPEN_P2P_SETTINGS, () =>
-            fireAndForget(() => {
-                return this._setupManager.onP2PManualSetup(UserMode.Update, this.settings, false);
-            })
-        );
-        return Promise.resolve(true);
-    }
-    async encodeQR() {
-        const settingString = encodeSettingsToQRCodeData(this.settings);
-        const codeSVG = encodeQR(settingString, OutputFormat.SVG);
-        if (codeSVG == "") {
-            return "";
-        }
-        const msg = $msg("Setup.QRCode", { qr_image: codeSVG });
-        await this.core.confirm.confirmWithMessage("Settings QR Code", msg, ["OK"], "OK");
-        return await Promise.resolve(codeSVG);
-    }
-
-    async askEncryptingPassphrase(): Promise<string | false> {
-        const encryptingPassphrase = await this.core.confirm.askString(
-            "Encrypt your settings",
-            "The passphrase to encrypt the setup URI",
-            "",
-            true
-        );
-        return encryptingPassphrase;
-    }
-
-    async command_copySetupURI(stripExtra = true) {
-        const encryptingPassphrase = await this.askEncryptingPassphrase();
-        if (encryptingPassphrase === false) return;
-        const encryptedURI = await encodeSettingsToSetupURI(
-            this.settings,
-            encryptingPassphrase,
-            [...((stripExtra ? ["pluginSyncExtendedSetting"] : []) as (keyof ObsidianLiveSyncSettings)[])],
-            true
-        );
-        if (await this.services.UI.promptCopyToClipboard("Setup URI", encryptedURI)) {
-            this._log("Setup URI copied to clipboard", LOG_LEVEL_NOTICE);
-        }
-        // await navigator.clipboard.writeText(encryptedURI);
-    }
-
-    async command_copySetupURIFull() {
-        const encryptingPassphrase = await this.askEncryptingPassphrase();
-        if (encryptingPassphrase === false) return;
-        const encryptedURI = await encodeSettingsToSetupURI(this.settings, encryptingPassphrase, [], false);
-        await navigator.clipboard.writeText(encryptedURI);
-        this._log("Setup URI copied to clipboard", LOG_LEVEL_NOTICE);
-    }
-
-    async command_copySetupURIWithSync() {
-        await this.command_copySetupURI(false);
-    }
-    async command_openSetupURI() {
-        await this._setupManager.onUseSetupURI(UserMode.Unknown);
-    }
-
-    // TODO: Where to implement these?
-
-    // async askSyncWithRemoteConfig(tryingSettings: ObsidianLiveSyncSettings): Promise<ObsidianLiveSyncSettings> {
-    //     const buttons = {
-    //         fetch: $msg("Setup.FetchRemoteConf.Buttons.Fetch"),
-    //         no: $msg("Setup.FetchRemoteConf.Buttons.Skip"),
-    //     } as const;
-    //     const fetchRemoteConf = await this.core.confirm.askSelectStringDialogue(
-    //         $msg("Setup.FetchRemoteConf.Message"),
-    //         Object.values(buttons),
-    //         { defaultAction: buttons.fetch, timeout: 0, title: $msg("Setup.FetchRemoteConf.Title") }
-    //     );
-    //     if (fetchRemoteConf == buttons.no) {
-    //         return tryingSettings;
-    //     }
-
-    //     const newSettings = JSON.parse(JSON.stringify(tryingSettings)) as ObsidianLiveSyncSettings;
-    //     const remoteConfig = await this.services.tweakValue.fetchRemotePreferred(newSettings);
-    //     if (remoteConfig) {
-    //         this._log("Remote configuration found.", LOG_LEVEL_NOTICE);
-    //         const resultSettings = {
-    //             ...DEFAULT_SETTINGS,
-    //             ...tryingSettings,
-    //             ...remoteConfig,
-    //         } satisfies ObsidianLiveSyncSettings;
-    //         return resultSettings;
-    //     } else {
-    //         this._log("Remote configuration not applied.", LOG_LEVEL_NOTICE);
-    //         return {
-    //             ...DEFAULT_SETTINGS,
-    //             ...tryingSettings,
-    //         } satisfies ObsidianLiveSyncSettings;
-    //     }
-    // }
-    // async askPerformDoctor(
-    //     tryingSettings: ObsidianLiveSyncSettings
-    // ): Promise<{ settings: ObsidianLiveSyncSettings; shouldRebuild: boolean; isModified: boolean }> {
-    //     const buttons = {
-    //         yes: $msg("Setup.Doctor.Buttons.Yes"),
-    //         no: $msg("Setup.Doctor.Buttons.No"),
-    //     } as const;
-    //     const performDoctor = await this.core.confirm.askSelectStringDialogue(
-    //         $msg("Setup.Doctor.Message"),
-    //         Object.values(buttons),
-    //         { defaultAction: buttons.yes, timeout: 0, title: $msg("Setup.Doctor.Title") }
-    //     );
-    //     if (performDoctor == buttons.no) {
-    //         return { settings: tryingSettings, shouldRebuild: false, isModified: false };
-    //     }
-
-    //     const newSettings = JSON.parse(JSON.stringify(tryingSettings)) as ObsidianLiveSyncSettings;
-    //     const { settings, shouldRebuild, isModified } = await performDoctorConsultation(this.core, newSettings, {
-    //         localRebuild: RebuildOptions.AutomaticAcceptable, // Because we are in the setup wizard, we can skip the confirmation.
-    //         remoteRebuild: RebuildOptions.SkipEvenIfRequired,
-    //         activateReason: "New settings from URI",
-    //     });
-    //     if (isModified) {
-    //         this._log("Doctor has fixed some issues!", LOG_LEVEL_NOTICE);
-    //         return {
-    //             settings,
-    //             shouldRebuild,
-    //             isModified,
-    //         };
-    //     } else {
-    //         this._log("Doctor detected no issues!", LOG_LEVEL_NOTICE);
-    //         return { settings: tryingSettings, shouldRebuild: false, isModified: false };
-    //     }
-    // }
-
-    override onBindFunction(core: LiveSyncCore, services: typeof core.services): void {
-        services.appLifecycle.onLoaded.addHandler(this._everyOnload.bind(this));
-    }
-}

src/modules/features/SettingDialogue/LiveSyncSetting.ts

@@ -8,12 +8,7 @@ import {
     type ValueComponent,
 } from "@/deps.ts";
 import { unique } from "octagonal-wheels/collection";
-import {
-    LEVEL_ADVANCED,
-    LEVEL_POWER_USER,
-    statusDisplay,
-    type ConfigurationItem,
-} from "../../../lib/src/common/types.ts";
+import { LEVEL_ADVANCED, LEVEL_POWER_USER, statusDisplay, type ConfigurationItem } from "@lib/common/types.ts";
 import { createStub, type ObsidianLiveSyncSettingTab } from "./ObsidianLiveSyncSettingTab.ts";
 import {
     type AllSettingItemKey,
@@ -23,7 +18,7 @@ import {
     type AllNumericItemKey,
     type AllBooleanItemKey,
 } from "./settingConstants.ts";
-import { $msg } from "src/lib/src/common/i18n.ts";
+import { $msg } from "@lib/common/i18n.ts";
 import { findAttrFromParent, wrapMemo, type AutoWireOption, type OnUpdateResult } from "./SettingPane.ts";
 
 export class LiveSyncSetting extends Setting {

src/modules/features/SettingDialogue/ObsidianLiveSyncSettingTab.ts

@@ -62,6 +62,7 @@ import { paneAdvanced } from "./PaneAdvanced.ts";
 import { panePowerUsers } from "./PanePowerUsers.ts";
 import { panePatches } from "./PanePatches.ts";
 import { paneMaintenance } from "./PaneMaintenance.ts";
+import { compatGlobal } from "@lib/common/coreEnvFunctions.ts";
 
 // For creating a document
 const toc = new Set<string>();
@@ -141,7 +142,7 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
 
     async saveLocalSetting(key: keyof typeof OnDialogSettingsDefault) {
         if (key == "configPassphrase") {
-            localStorage.setItem("ls-setting-passphrase", this.editingSettings?.[key] ?? "");
+            compatGlobal.localStorage.setItem("ls-setting-passphrase", this.editingSettings?.[key] ?? "");
             return await Promise.resolve();
         }
         if (key == "deviceAndVaultName") {
@@ -180,7 +181,7 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
         // if (runOnSaved) {
         const handlers = this.onSavedHandlers
             .filter((e) => appliedKeys.indexOf(e.key) !== -1)
-            .map((e) => e.handler(this.editingSettings[e.key as AllSettingItemKey]));
+            .map((e) => Promise.resolve(e.handler(this.editingSettings[e.key as AllSettingItemKey])));
         await Promise.all(handlers);
         // }
         keys.forEach((e) => this.refreshSetting(e));
@@ -214,7 +215,7 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
 
     reloadAllLocalSettings() {
         const ret = { ...OnDialogSettingsDefault };
-        ret.configPassphrase = localStorage.getItem("ls-setting-passphrase") || "";
+        ret.configPassphrase = compatGlobal.localStorage.getItem("ls-setting-passphrase") || "";
         ret.preset = "";
         ret.deviceAndVaultName = this.services.setting.getDeviceAndVaultName();
         return ret;
@@ -349,7 +350,7 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
     createEl<T extends keyof HTMLElementTagNameMap>(
         el: HTMLElement,
         tag: T,
-        o?: string | DomElementInfo | undefined,
+        o?: string | DomElementInfo,
         callback?: (el: HTMLElementTagNameMap[T]) => void,
         func?: OnUpdateFunc
     ) {
@@ -361,7 +362,7 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
     addEl<T extends keyof HTMLElementTagNameMap>(
         el: HTMLElement,
         tag: T,
-        o?: string | DomElementInfo | undefined,
+        o?: string | DomElementInfo,
         callback?: (el: HTMLElementTagNameMap[T]) => void,
         func?: OnUpdateFunc
     ) {
@@ -647,7 +648,7 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
             this.editingSettings.passphrase = "";
         }
         await this.saveAllDirtySettings();
-        await this.applyAllSettings();
+        await Promise.resolve(this.applyAllSettings());
         if (result == OPTION_FETCH) {
             await this.core.storageAccess.writeFileAuto(FLAGMD_REDFLAG3_HR, "");
             this.services.appLifecycle.scheduleRestart();
@@ -738,6 +739,8 @@ export class ObsidianLiveSyncSettingTab extends PluginSettingTab {
                 );
             }
             setLevelClass(el, level);
+            // TODO: Refactor to use Obsidian's recommended way to create heading.
+            // eslint-disable-next-line obsidianmd/settings-tab/no-manual-html-headings
             el.createEl("h3", { text: title, cls: "sls-setting-pane-title" });
             if (this.menuEl) {
                 this.menuEl.createEl(

src/modules/features/SettingDialogue/PaneAdvanced.ts

@@ -35,6 +35,7 @@ export function paneAdvanced(this: ObsidianLiveSyncSettingTab, paneEl: HTMLEleme
             clampMin: 10,
             onUpdate: this.onlyOnCouchDB,
         });
+        new Setting(paneEl).setClass("wizardHidden").autoWireToggle("autoAcceptCompatibleTweak");
         // new Setting(paneEl)
         //     .setClass("wizardHidden")
         //     .autoWireToggle("sendChunksBulk", { onUpdate: onlyOnCouchDB })

src/modules/features/SettingDialogue/PaneChangeLog.ts

@@ -43,10 +43,13 @@ export function paneChangeLog(this: ObsidianLiveSyncSettingTab, paneEl: HTMLElem
     // tmpDiv.addClass("sls-header-button");
     tmpDiv.addClass("op-warn-info");
 
-    tmpDiv.innerHTML = `<p>${$msg("obsidianLiveSyncSettingTab.msgNewVersionNote")}</p><button>${$msg("obsidianLiveSyncSettingTab.optionOkReadEverything")}</button>`;
+    tmpDiv.createEl("p", { text: $msg("obsidianLiveSyncSettingTab.msgNewVersionNote") });
+    const readEverythingButton = tmpDiv.createEl("button", {
+        text: $msg("obsidianLiveSyncSettingTab.optionOkReadEverything"),
+    });
     if (lastVersion > (this.editingSettings?.lastReadUpdates || 0)) {
         const informationButtonDiv = informationDivEl.appendChild(tmpDiv);
-        informationButtonDiv.querySelector("button")?.addEventListener("click", () => {
+        readEverythingButton.addEventListener("click", () => {
             fireAndForget(async () => {
                 this.editingSettings.lastReadUpdates = lastVersion;
                 await this.saveAllDirtySettings();

src/modules/features/SettingDialogue/PaneHatch.ts

@@ -1,29 +1,16 @@
-import { stringifyYaml } from "../../../deps.ts";
 import {
-    type ObsidianLiveSyncSettings,
     type FilePathWithPrefix,
     type DocumentID,
     LOG_LEVEL_NOTICE,
     LOG_LEVEL_VERBOSE,
     type LoadedEntry,
-    REMOTE_COUCHDB,
-    REMOTE_MINIO,
     type MetaEntry,
     type FilePath,
-    DEFAULT_SETTINGS,
-} from "../../../lib/src/common/types.ts";
-import {
-    createBlob,
-    getFileRegExp,
-    isDocContentSame,
-    parseHeaderValues,
-    readAsBlob,
-} from "../../../lib/src/common/utils.ts";
-import { Logger } from "../../../lib/src/common/logger.ts";
-import { isCloudantURI } from "../../../lib/src/pouchdb/utils_couchdb.ts";
-import { requestToCouchDBWithCredentials } from "../../../common/utils.ts";
-import { addPrefix, shouldBeIgnored, stripAllPrefixes } from "../../../lib/src/string_and_binary/path.ts";
-import { $msg } from "../../../lib/src/common/i18n.ts";
+} from "@lib/common/types.ts";
+import { createBlob, getFileRegExp, isDocContentSame, readAsBlob } from "@lib/common/utils.ts";
+import { Logger } from "@lib/common/logger.ts";
+import { addPrefix, shouldBeIgnored, stripAllPrefixes } from "@lib/string_and_binary/path.ts";
+import { $msg } from "@lib/common/i18n.ts";
 import { Semaphore } from "octagonal-wheels/concurrency/semaphore";
 import { LiveSyncSetting as Setting } from "./LiveSyncSetting.ts";
 import {
@@ -32,13 +19,13 @@ import {
     EVENT_REQUEST_RUN_DOCTOR,
     EVENT_REQUEST_RUN_FIX_INCOMPLETE,
     eventHub,
-} from "../../../common/events.ts";
-import { ICHeader, ICXHeader, PSCHeader } from "../../../common/types.ts";
-import { HiddenFileSync } from "../../../features/HiddenFileSync/CmdHiddenFileSync.ts";
-import { EVENT_REQUEST_SHOW_HISTORY } from "../../../common/obsidianEvents.ts";
-import { generateCredentialObject } from "../../../lib/src/replication/httplib.ts";
+} from "@/common/events.ts";
+import { ICHeader, ICXHeader, PSCHeader } from "@/common/types.ts";
+import { HiddenFileSync } from "@/features/HiddenFileSync/CmdHiddenFileSync.ts";
+import { EVENT_REQUEST_SHOW_HISTORY } from "@/common/obsidianEvents.ts";
 import type { ObsidianLiveSyncSettingTab } from "./ObsidianLiveSyncSettingTab.ts";
 import type { PageFunctions } from "./SettingPane.ts";
+import { isNotFoundError } from "@lib/common/utils.doc.ts";
 export function paneHatch(this: ObsidianLiveSyncSettingTab, paneEl: HTMLElement, { addPanel }: PageFunctions): void {
     // const hatchWarn = this.createEl(paneEl, "div", { text: `To stop the boot up sequence for fixing problems on databases, you can put redflag.md on top of your vault (Rebooting obsidian is required).` });
     // hatchWarn.addClass("op-warn-info");
@@ -69,140 +56,14 @@ export function paneHatch(this: ObsidianLiveSyncSettingTab, paneEl: HTMLElement,
                         eventHub.emitEvent(EVENT_REQUEST_RUN_FIX_INCOMPLETE);
                     })
             );
+
         new Setting(paneEl).setName($msg("Prepare the 'report' to create an issue")).addButton((button) =>
             button
                 .setButtonText($msg("Copy Report to clipboard"))
                 .setCta()
                 .setDisabled(false)
                 .onClick(async () => {
-                    let responseConfig: any = {};
-                    const REDACTED = "𝑅𝐸𝐷𝐴𝐶𝑇𝐸𝐷";
-                    if (this.editingSettings.remoteType == REMOTE_COUCHDB) {
-                        try {
-                            const credential = generateCredentialObject(this.editingSettings);
-                            const customHeaders = parseHeaderValues(this.editingSettings.couchDB_CustomHeaders);
-                            const r = await requestToCouchDBWithCredentials(
-                                this.editingSettings.couchDB_URI,
-                                credential,
-                                window.origin,
-                                undefined,
-                                undefined,
-                                undefined,
-                                customHeaders
-                            );
-
-                            Logger(JSON.stringify(r.json, null, 2));
-
-                            responseConfig = r.json;
-                            responseConfig["couch_httpd_auth"].secret = REDACTED;
-                            responseConfig["couch_httpd_auth"].authentication_db = REDACTED;
-                            responseConfig["couch_httpd_auth"].authentication_redirect = REDACTED;
-                            responseConfig["couchdb"].uuid = REDACTED;
-                            responseConfig["admins"] = REDACTED;
-                            delete responseConfig["jwt_keys"];
-                            if ("secret" in responseConfig["chttpd_auth"])
-                                responseConfig["chttpd_auth"].secret = REDACTED;
-                        } catch (ex) {
-                            Logger(ex, LOG_LEVEL_VERBOSE);
-                            responseConfig = {
-                                error: "Requesting information from the remote CouchDB has failed. If you are using IBM Cloudant, this is normal behaviour.",
-                            };
-                        }
-                    } else if (this.editingSettings.remoteType == REMOTE_MINIO) {
-                        responseConfig = { error: "Object Storage Synchronisation" };
-                        //
-                    }
-                    const defaultKeys = Object.keys(DEFAULT_SETTINGS) as (keyof ObsidianLiveSyncSettings)[];
-                    const pluginConfig = JSON.parse(JSON.stringify(this.editingSettings)) as ObsidianLiveSyncSettings;
-                    const pluginKeys = Object.keys(pluginConfig);
-                    for (const key of pluginKeys) {
-                        if (defaultKeys.includes(key as any)) continue;
-                        delete pluginConfig[key as keyof ObsidianLiveSyncSettings];
-                    }
-
-                    pluginConfig.couchDB_DBNAME = REDACTED;
-                    pluginConfig.couchDB_PASSWORD = REDACTED;
-                    const scheme = pluginConfig.couchDB_URI.startsWith("http:")
-                        ? "(HTTP)"
-                        : pluginConfig.couchDB_URI.startsWith("https:")
-                          ? "(HTTPS)"
-                          : "";
-                    pluginConfig.couchDB_URI = isCloudantURI(pluginConfig.couchDB_URI)
-                        ? "cloudant"
-                        : `self-hosted${scheme}`;
-                    pluginConfig.couchDB_USER = REDACTED;
-                    pluginConfig.passphrase = REDACTED;
-                    pluginConfig.encryptedPassphrase = REDACTED;
-                    pluginConfig.encryptedCouchDBConnection = REDACTED;
-                    pluginConfig.accessKey = REDACTED;
-                    pluginConfig.secretKey = REDACTED;
-                    const redact = (source: string) => `${REDACTED}(${source.length} letters)`;
-                    const toSchemeOnly = (uri: string) => {
-                        try {
-                            return `${new URL(uri).protocol}//`;
-                        } catch {
-                            const matched = uri.match(/^[A-Za-z][A-Za-z0-9+.-]*:\/\//);
-                            return matched?.[0] ?? REDACTED;
-                        }
-                    };
-                    pluginConfig.remoteConfigurations = Object.fromEntries(
-                        Object.entries(pluginConfig.remoteConfigurations || {}).map(([id, config]) => [
-                            id,
-                            {
-                                ...config,
-                                uri: toSchemeOnly(config.uri),
-                            },
-                        ])
-                    );
-                    pluginConfig.region = redact(pluginConfig.region);
-                    pluginConfig.bucket = redact(pluginConfig.bucket);
-                    pluginConfig.pluginSyncExtendedSetting = {};
-                    pluginConfig.P2P_AppID = redact(pluginConfig.P2P_AppID);
-                    pluginConfig.P2P_passphrase = redact(pluginConfig.P2P_passphrase);
-                    pluginConfig.P2P_roomID = redact(pluginConfig.P2P_roomID);
-                    pluginConfig.P2P_relays = redact(pluginConfig.P2P_relays);
-                    pluginConfig.jwtKey = redact(pluginConfig.jwtKey);
-                    pluginConfig.jwtSub = redact(pluginConfig.jwtSub);
-                    pluginConfig.jwtKid = redact(pluginConfig.jwtKid);
-                    pluginConfig.bucketCustomHeaders = redact(pluginConfig.bucketCustomHeaders);
-                    pluginConfig.couchDB_CustomHeaders = redact(pluginConfig.couchDB_CustomHeaders);
-                    pluginConfig.P2P_turnCredential = redact(pluginConfig.P2P_turnCredential);
-                    pluginConfig.P2P_turnUsername = redact(pluginConfig.P2P_turnUsername);
-                    pluginConfig.P2P_turnServers = `(${pluginConfig.P2P_turnServers.split(",").length} servers configured)`;
-                    const endpoint = pluginConfig.endpoint;
-                    if (endpoint == "") {
-                        pluginConfig.endpoint = "Not configured or AWS";
-                    } else {
-                        const endpointScheme = pluginConfig.endpoint.startsWith("http:")
-                            ? "(HTTP)"
-                            : pluginConfig.endpoint.startsWith("https:")
-                              ? "(HTTPS)"
-                              : "";
-                        pluginConfig.endpoint = `${endpoint.indexOf(".r2.cloudflarestorage.") !== -1 ? "R2" : "self-hosted?"}(${endpointScheme})`;
-                    }
-                    const obsidianInfo = {
-                        navigator: navigator.userAgent,
-                        fileSystem: this.core.services.vault.isStorageInsensitive() ? "insensitive" : "sensitive",
-                    };
-                    const msgConfig = `# ---- Obsidian info ----
-${stringifyYaml(obsidianInfo)}
----
-# ---- remote config ----
-${stringifyYaml(responseConfig)}
----
-# ---- Plug-in config ----
-${stringifyYaml({
-    version: this.manifestVersion,
-    ...pluginConfig,
-})}`;
-                    console.log(msgConfig);
-                    if ((await this.services.UI.promptCopyToClipboard("Generated report", msgConfig)) == true) {
-                        // await navigator.clipboard.writeText(msgConfig);
-                        // Logger(
-                        //     `Generated report has been copied to clipboard. Please report the issue with this! Thank you for your cooperation!`,
-                        //     LOG_LEVEL_NOTICE
-                        // );
-                    }
+                    await this.app.commands.executeCommandById("obsidian-livesync:dump-debug-info");
                 })
         );
         new Setting(paneEl)
@@ -285,14 +146,14 @@ ${stringifyYaml({
                                             }
                                             if (!(await addOn.storeInternalFileToDatabase(file, true))) {
                                                 Logger(
-                                                    `Failed to store the file to the database (Hidden file): ${file}`,
+                                                    `Failed to store the file to the database (Hidden file): ${file.path}`,
                                                     LOG_LEVEL_NOTICE
                                                 );
                                                 return;
                                             }
                                         }
                                     } else {
-                                        if (!(await this.core.fileHandler.storeFileToDB(file as FilePath, true))) {
+                                        if (!(await this.core.fileHandler.storeFileToDB(file, true))) {
                                             Logger(
                                                 `Failed to store the file to the database: ${file}`,
                                                 LOG_LEVEL_NOTICE
@@ -531,8 +392,8 @@ ${stringifyYaml({
                                         Logger(`Converting ${docName} Failed!`, LOG_LEVEL_NOTICE);
                                         Logger(ret, LOG_LEVEL_VERBOSE);
                                     }
-                                } catch (ex: any) {
-                                    if (ex?.status == 404) {
+                                } catch (ex: unknown) {
+                                    if (isNotFoundError(ex)) {
                                         // We can perform this safely
                                         if ((await this.core.localDatabase.putRaw(newDoc)).ok) {
                                             Logger(`${docName} has been converted`, LOG_LEVEL_NOTICE);

src/modules/features/SettingDialogue/PanePatches.ts

@@ -6,7 +6,6 @@ import {
     SuffixDatabaseName,
 } from "../../../lib/src/common/types.ts";
 import { Logger } from "../../../lib/src/common/logger.ts";
-import { generateUserHashSalt } from "../../../lib/src/common/utils.ts";
 import { LiveSyncSetting as Setting } from "./LiveSyncSetting.ts";
 import type { ObsidianLiveSyncSettingTab } from "./ObsidianLiveSyncSettingTab.ts";
 import type { PageFunctions } from "./SettingPane.ts";
@@ -151,48 +150,12 @@ export function panePatches(this: ObsidianLiveSyncSettingTab, paneEl: HTMLElemen
                 xxhash64: "xxhash64 (Fastest)",
                 "mixed-purejs": "PureJS fallback  (Fast, W/O WebAssembly)",
                 sha1: "Older fallback (Slow, W/O WebAssembly)",
-            } as Record<HashAlgorithm, string>,
+            } satisfies Record<HashAlgorithm, string>,
         });
         this.addOnSaved("hashAlg", async () => {
             await this.core.localDatabase._prepareHashFunctions();
         });
     });
-
-    void addPanel(paneEl, "Chunk ID Namespace").then((paneEl) => {
-        paneEl.createDiv({
-            text: "Manage the Chunk ID Namespace Salt (userHashSalt). This value is used as a seed for generating chunk IDs. If you change this value, chunk IDs will be regenerated and you must rebuild the database.",
-            cls: "op-warn-info",
-        });
-
-        new Setting(paneEl)
-            .autoWireText("userHashSalt", { holdValue: true })
-            .setClass("wizardHidden")
-            .addApplyButton(["userHashSalt"]);
-
-        new Setting(paneEl)
-            .setName("Generate New Salt")
-            .setDesc(
-                "Generate a new random salt for the Chunk ID namespace. After generating, a database rebuild is strongly recommended."
-            )
-            .addButton((button) => {
-                button
-                    .setButtonText("Generate New Salt")
-                    .setCta()
-                    .onClick(async () => {
-                        const confirmed = await this.core.confirm.askYesNo(
-                            "Generating a new salt will invalidate existing chunk IDs. Until you rebuild the database, deduplication will be inefficient. Are you sure to generate a new salt now?"
-                        );
-                        if (confirmed) {
-                            const newSalt = generateUserHashSalt();
-                            this.editingSettings.userHashSalt = newSalt;
-                            await this.saveSettings(["userHashSalt"]);
-                            Logger(`New Chunk ID Namespace Salt generated.`, LOG_LEVEL_NOTICE);
-                            this.requestUpdate();
-                        }
-                    });
-            });
-    });
-
     void addPanel(paneEl, "Edge case addressing (Behaviour)").then((paneEl) => {
         new Setting(paneEl).autoWireToggle("doNotSuspendOnFetching");
         new Setting(paneEl).setClass("wizardHidden").autoWireToggle("doNotDeleteFolder");
@@ -225,7 +188,7 @@ export function panePatches(this: ObsidianLiveSyncSettingTab, paneEl: HTMLElemen
                     }
                     this.requestUpdate();
                 };
-                text.inputEl.before((dateEl = document.createElement("span")));
+                text.inputEl.before((dateEl = activeDocument.createElement("span")));
                 text.inputEl.type = "datetime-local";
                 if (this.editingSettings.maxMTimeForReflectEvents > 0) {
                     const date = new Date(this.editingSettings.maxMTimeForReflectEvents);

src/modules/features/SettingDialogue/PaneRemoteConfig.ts

@@ -5,6 +5,7 @@ import {
     DEFAULT_SETTINGS,
     LOG_LEVEL_NOTICE,
     type ObsidianLiveSyncSettings,
+    LOG_LEVEL_VERBOSE,
 } from "../../../lib/src/common/types.ts";
 import { Menu } from "@/deps.ts";
 import { $msg } from "../../../lib/src/common/i18n.ts";
@@ -288,7 +289,8 @@ export function paneRemoteConfig(
                 try {
                     parsed = ConnectionStringParser.parse(trimmedURI);
                 } catch (ex) {
-                    this.services.API.addLog(`Failed to import remote configuration: ${ex}`, LOG_LEVEL_NOTICE);
+                    this.services.API.addLog(`Failed to import remote configuration!`, LOG_LEVEL_NOTICE);
+                    this.services.API.addLog(ex, LOG_LEVEL_VERBOSE);
                     return;
                 }
 
@@ -343,9 +345,10 @@ export function paneRemoteConfig(
                                 parsed = ConnectionStringParser.parse(config.uri);
                             } catch (ex) {
                                 this.services.API.addLog(
-                                    `Failed to parse remote configuration '${config.id}' for editing: ${ex}`,
+                                    `Failed to parse remote configuration '${config.id}' for editing!`,
                                     LOG_LEVEL_NOTICE
                                 );
+                                this.services.API.addLog(ex, LOG_LEVEL_VERBOSE);
                                 return;
                             }
                             const workSettings = createBaseRemoteSettings();
@@ -452,9 +455,10 @@ export function paneRemoteConfig(
                                             parsed = ConnectionStringParser.parse(config.uri);
                                         } catch (ex) {
                                             this.services.API.addLog(
-                                                `Failed to parse remote configuration '${config.id}': ${ex}`,
+                                                `Failed to parse remote configuration '${config.id}' for fetching settings!`,
                                                 LOG_LEVEL_NOTICE
                                             );
+                                            this.services.API.addLog(ex, LOG_LEVEL_VERBOSE);
                                             return;
                                         }
                                         const workSettings = createBaseRemoteSettings();

src/modules/features/SettingDialogue/PaneSetup.ts

@@ -121,13 +121,13 @@ export function paneSetup(
         const repo = "vrtmrz/obsidian-livesync";
         const topPath = $msg("obsidianLiveSyncSettingTab.linkTroubleshooting");
         const rawRepoURI = `https://raw.githubusercontent.com/${repo}/main`;
-        this.createEl(
-            paneEl,
-            "div",
-            "",
-            (el) =>
-                (el.innerHTML = `<a href='https://github.com/${repo}/blob/main${topPath}' target="_blank">${$msg("obsidianLiveSyncSettingTab.linkOpenInBrowser")}</a>`)
-        );
+        this.createEl(paneEl, "div", "", (el) => {
+            el.createEl("a", { text: $msg("obsidianLiveSyncSettingTab.linkOpenInBrowser") }, (anchor) => {
+                anchor.href = `https://github.com/${repo}/blob/main${topPath}`;
+                anchor.target = "_blank";
+                anchor.rel = "noopener";
+            });
+        });
         const troubleShootEl = this.createEl(paneEl, "div", {
             text: "",
             cls: "sls-troubleshoot-preview",

src/modules/features/SettingDialogue/settingUtils.ts

@@ -75,7 +75,7 @@ export function getSummaryFromPartialSettings(setting: Partial<ObsidianLiveSyncS
         if (config.isAdvanced && !showAdvanced) continue;
         const value =
             key != "E2EEAlgorithm"
-                ? `${setting[key]}`
+                ? `${setting[key] as string}`
                 : E2EEAlgorithmNames[`${setting[key]}` as keyof typeof E2EEAlgorithmNames];
         const displayValue = config.isHidden ? "•".repeat(value.length) : escapeStringToHTML(value);
         outputSummary[config.name] = displayValue;

src/modules/features/SettingDialogue/utilFixCouchDBSetting.ts

@@ -13,7 +13,7 @@ export const checkConfig = async (
     Logger($msg("obsidianLiveSyncSettingTab.logCheckingDbConfig"), LOG_LEVEL_INFO);
     let isSuccessful = true;
     const emptyDiv = createDiv();
-    emptyDiv.innerHTML = "<span></span>";
+    emptyDiv.createSpan();
     checkResultDiv?.replaceChildren(...[emptyDiv]);
     const addResult = (msg: string, classes?: string[]) => {
         const tmpDiv = createDiv();
@@ -21,7 +21,7 @@ export const checkConfig = async (
         if (classes) {
             tmpDiv.addClasses(classes);
         }
-        tmpDiv.innerHTML = `${msg}`;
+        tmpDiv.textContent = msg;
         checkResultDiv?.appendChild(tmpDiv);
     };
     try {
@@ -47,9 +47,10 @@ export const checkConfig = async (
             if (!checkResultDiv) return;
             const tmpDiv = createDiv();
             tmpDiv.addClass("ob-btn-config-fix");
-            tmpDiv.innerHTML = `<label>${title}</label><button>${$msg("obsidianLiveSyncSettingTab.btnFix")}</button>`;
+            tmpDiv.createEl("label", { text: title });
+            const fixButton = tmpDiv.createEl("button", { text: $msg("obsidianLiveSyncSettingTab.btnFix") });
             const x = checkResultDiv.appendChild(tmpDiv);
-            x.querySelector("button")?.addEventListener("click", () => {
+            fixButton.addEventListener("click", () => {
                 fireAndForget(async () => {
                     Logger($msg("obsidianLiveSyncSettingTab.logCouchDbConfigSet", { title, key, value }));
                     const res = await requestToCouchDBWithCredentials(

src/modules/features/SetupManager.ts

@@ -1,13 +1,17 @@
 import {
+    type BucketSyncSetting,
+    type CouchDBConnection,
+    type EncryptionSettings,
     type ObsidianLiveSyncSettings,
+    type P2PSyncSetting,
     DEFAULT_SETTINGS,
     LOG_LEVEL_NOTICE,
     LOG_LEVEL_VERBOSE,
     REMOTE_COUCHDB,
     REMOTE_MINIO,
     REMOTE_P2P,
-} from "../../lib/src/common/types.ts";
-import { generatePatchObj, isObjectDifferent, generateUserHashSalt } from "../../lib/src/common/utils.ts";
+} from "@lib/common/types.ts";
+import { isObjectDifferent } from "@lib/common/utils.ts";
 import Intro from "./SetupWizard/dialogs/Intro.svelte";
 import SelectMethodNewUser from "./SetupWizard/dialogs/SelectMethodNewUser.svelte";
 import SelectMethodExisting from "./SetupWizard/dialogs/SelectMethodExisting.svelte";
@@ -21,8 +25,21 @@ import SetupRemoteCouchDB from "./SetupWizard/dialogs/SetupRemoteCouchDB.svelte"
 import SetupRemoteBucket from "./SetupWizard/dialogs/SetupRemoteBucket.svelte";
 import SetupRemoteP2P from "./SetupWizard/dialogs/SetupRemoteP2P.svelte";
 import SetupRemoteE2EE from "./SetupWizard/dialogs/SetupRemoteE2EE.svelte";
-import { decodeSettingsFromQRCodeData } from "../../lib/src/API/processSetting.ts";
+import { decodeSettingsFromQRCodeData } from "@lib/API/processSetting.ts";
 import { AbstractModule } from "../AbstractModule.ts";
+import { ConnectionStringParser } from "@lib/common/ConnectionString.ts";
+import type {
+    OutroAskUserModeResultType,
+    OutroExistingUserResultType,
+    OutroNewUserResultType,
+    ScanQRCodeResultType,
+    SetupRemoteBucketResultType,
+    SetupRemoteCouchDBResultType,
+    SetupRemoteE2EEResultType,
+    SetupRemoteP2PResultType,
+    SetupRemoteResultType,
+    UseSetupURIResultType,
+} from "./SetupWizard/dialogs/setupDialogTypes.ts";
 
 /**
  * User modes for onboarding and setup
@@ -117,7 +134,10 @@ export class SetupManager extends AbstractModule {
      * @returns Promise that resolves to true if onboarding completed successfully, false otherwise
      */
     async onUseSetupURI(userMode: UserMode, setupURI: string = ""): Promise<boolean> {
-        const newSetting = await this.dialogManager.openWithExplicitCancel(UseSetupURI, setupURI);
+        const newSetting = await this.dialogManager.openWithExplicitCancel<UseSetupURIResultType, string>(
+            UseSetupURI,
+            setupURI
+        );
         if (newSetting === "cancelled") {
             this._log("Setup URI dialog cancelled.", LOG_LEVEL_NOTICE);
             return false;
@@ -140,7 +160,10 @@ export class SetupManager extends AbstractModule {
     ): Promise<boolean> {
         const originalSetting = JSON.parse(JSON.stringify(currentSetting)) as ObsidianLiveSyncSettings;
         const baseSetting = JSON.parse(JSON.stringify(originalSetting)) as ObsidianLiveSyncSettings;
-        const couchConf = await this.dialogManager.openWithExplicitCancel(SetupRemoteCouchDB, originalSetting);
+        const couchConf = await this.dialogManager.openWithExplicitCancel<
+            SetupRemoteCouchDBResultType,
+            CouchDBConnection
+        >(SetupRemoteCouchDB, originalSetting);
         if (couchConf === "cancelled") {
             this._log("Manual configuration cancelled.", LOG_LEVEL_NOTICE);
             return await this.onOnboard(userMode);
@@ -164,7 +187,10 @@ export class SetupManager extends AbstractModule {
         currentSetting: ObsidianLiveSyncSettings,
         activate = true
     ): Promise<boolean> {
-        const bucketConf = await this.dialogManager.openWithExplicitCancel(SetupRemoteBucket, currentSetting);
+        const bucketConf = await this.dialogManager.openWithExplicitCancel<
+            SetupRemoteBucketResultType,
+            BucketSyncSetting
+        >(SetupRemoteBucket, currentSetting);
         if (bucketConf === "cancelled") {
             this._log("Manual configuration cancelled.", LOG_LEVEL_NOTICE);
             return await this.onOnboard(userMode);
@@ -188,14 +214,33 @@ export class SetupManager extends AbstractModule {
         currentSetting: ObsidianLiveSyncSettings,
         activate = true
     ): Promise<boolean> {
-        const p2pConf = await this.dialogManager.openWithExplicitCancel(SetupRemoteP2P, currentSetting);
+        const p2pConf = await this.dialogManager.openWithExplicitCancel<SetupRemoteP2PResultType, P2PSyncSetting>(
+            SetupRemoteP2P,
+            currentSetting
+        );
         if (p2pConf === "cancelled") {
             this._log("Manual configuration cancelled.", LOG_LEVEL_NOTICE);
             return await this.onOnboard(userMode);
         }
         const newSetting = { ...currentSetting, ...p2pConf } as ObsidianLiveSyncSettings;
+        // Apply remoteConfigurations
+        if (newSetting.P2P_ActiveRemoteConfigurationId) {
+            const id = newSetting.P2P_ActiveRemoteConfigurationId;
+            const merged = {
+                ...newSetting,
+                ...p2pConf,
+            } as ObsidianLiveSyncSettings;
+            const uri = ConnectionStringParser.serialize({ type: "p2p", settings: merged });
+            newSetting.remoteConfigurations[id] = {
+                ...newSetting.remoteConfigurations[id],
+                uri,
+                isEncrypted: false,
+            };
+            newSetting.P2P_ActiveRemoteConfigurationId = id;
+        }
         if (activate) {
             newSetting.remoteType = REMOTE_P2P;
+            newSetting.activeConfigurationId = newSetting.P2P_ActiveRemoteConfigurationId;
         }
         return await this.onConfirmApplySettingsFromWizard(newSetting, userMode, activate);
     }
@@ -207,10 +252,13 @@ export class SetupManager extends AbstractModule {
      * @returns
      */
     async onlyE2EEConfiguration(userMode: UserMode, currentSetting: ObsidianLiveSyncSettings): Promise<boolean> {
-        const e2eeConf = await this.dialogManager.openWithExplicitCancel(SetupRemoteE2EE, currentSetting);
+        const e2eeConf = await this.dialogManager.openWithExplicitCancel<SetupRemoteE2EEResultType, EncryptionSettings>(
+            SetupRemoteE2EE,
+            currentSetting
+        );
         if (e2eeConf === "cancelled") {
             this._log("E2EE configuration cancelled.", LOG_LEVEL_NOTICE);
-            return await false;
+            return false;
         }
         const newSetting = {
             ...currentSetting,
@@ -226,7 +274,10 @@ export class SetupManager extends AbstractModule {
      * @returns
      */
     async onConfigureManually(originalSetting: ObsidianLiveSyncSettings, userMode: UserMode): Promise<boolean> {
-        const e2eeConf = await this.dialogManager.openWithExplicitCancel(SetupRemoteE2EE, originalSetting);
+        const e2eeConf = await this.dialogManager.openWithExplicitCancel<SetupRemoteE2EEResultType, EncryptionSettings>(
+            SetupRemoteE2EE,
+            originalSetting
+        );
         if (e2eeConf === "cancelled") {
             this._log("Manual configuration cancelled.", LOG_LEVEL_NOTICE);
             return await this.onOnboard(userMode);
@@ -245,7 +296,7 @@ export class SetupManager extends AbstractModule {
      * @returns
      */
     async onSelectServer(currentSetting: ObsidianLiveSyncSettings, userMode: UserMode): Promise<boolean> {
-        const method = await this.dialogManager.openWithExplicitCancel(SetupRemote);
+        const method = await this.dialogManager.openWithExplicitCancel<SetupRemoteResultType>(SetupRemote);
         if (method === "couchdb") {
             return await this.onCouchDBManualSetup(userMode, currentSetting, true);
         } else if (method === "bucket") {
@@ -285,9 +336,9 @@ export class SetupManager extends AbstractModule {
                 this._log("No changes in settings detected. Skipping applying settings from wizard.", LOG_LEVEL_NOTICE);
                 return true;
             }
-            const patch = generatePatchObj(this.settings, newConf);
-            console.log(`Changes:`);
-            console.dir(patch);
+            // const patch = generatePatchObj(this.settings, newConf);
+            // console.log(`Changes:`);
+            // console.dir(patch);
             if (!activate) {
                 extra();
                 await this.applySetting(newConf, UserMode.ExistingUser);
@@ -304,7 +355,8 @@ export class SetupManager extends AbstractModule {
                 this._log("Settings from wizard applied.", LOG_LEVEL_NOTICE);
                 return true;
             } else {
-                const userModeResult = await this.dialogManager.openWithExplicitCancel(OutroAskUserMode);
+                const userModeResult =
+                    await this.dialogManager.openWithExplicitCancel<OutroAskUserModeResultType>(OutroAskUserMode);
                 if (userModeResult === "new-user") {
                     userMode = UserMode.NewUser;
                 } else if (userModeResult === "existing-user") {
@@ -321,16 +373,15 @@ export class SetupManager extends AbstractModule {
             }
         }
         const component = userMode === UserMode.NewUser ? OutroNewUser : OutroExistingUser;
-        const confirm = await this.dialogManager.openWithExplicitCancel(component);
+        const confirm = await this.dialogManager.openWithExplicitCancel<
+            OutroNewUserResultType | OutroExistingUserResultType
+        >(component);
         if (confirm === "cancelled") {
             this._log("User cancelled applying settings from wizard..", LOG_LEVEL_NOTICE);
             return false;
         }
         if (confirm) {
             extra();
-            if (userMode === UserMode.NewUser && !newConf.userHashSalt) {
-                newConf.userHashSalt = generateUserHashSalt();
-            }
             await this.applySetting(newConf, userMode);
             if (userMode === UserMode.NewUser) {
                 // For new users, schedule a rebuild everything.
@@ -350,10 +401,10 @@ export class SetupManager extends AbstractModule {
      */
 
     async onPromptQRCodeInstruction(): Promise<boolean> {
-        const qrResult = await this.dialogManager.open(ScanQRCode);
+        const qrResult = await this.dialogManager.open<ScanQRCodeResultType>(ScanQRCode);
         this._log("QR Code dialog closed.", LOG_LEVEL_VERBOSE);
         // Result is not used, but log it for debugging.
-        this._log(`QR Code result: ${qrResult}`, LOG_LEVEL_VERBOSE);
+        this._log(qrResult, LOG_LEVEL_VERBOSE);
         // QR Code instruction dialog never yields settings directly.
         return false;
     }

src/modules/features/SetupManager.unit.spec.ts

@@ -154,47 +154,4 @@ describe("SetupManager", () => {
         );
         expect(setting.currentSettings().activeConfigurationId).toBe("legacy-couchdb");
     });
-
-    it("onConfirmApplySettingsFromWizard should generate userHashSalt for NewUser when absent", async () => {
-        const { manager, setting, dialogManager, core } = createSetupManager();
-        const randomSpy = vi.spyOn(globalThis.crypto, "getRandomValues").mockImplementation((array) => {
-            const target = array as Uint8Array;
-            for (let i = 0; i < target.length; i++) {
-                target[i] = 0xab;
-            }
-            return array;
-        });
-        dialogManager.openWithExplicitCancel.mockResolvedValueOnce(true);
-
-        await manager.onConfirmApplySettingsFromWizard(
-            {
-                ...setting.currentSettings(),
-                userHashSalt: "",
-            },
-            UserMode.NewUser
-        );
-
-        expect(setting.currentSettings().userHashSalt).toBe("abababababababababababababababab");
-        expect(core.rebuilder.scheduleRebuild).toHaveBeenCalledTimes(1);
-        randomSpy.mockRestore();
-    });
-
-    it("onConfirmApplySettingsFromWizard should keep existing userHashSalt for NewUser", async () => {
-        const { manager, setting, dialogManager, core } = createSetupManager();
-        const randomSpy = vi.spyOn(globalThis.crypto, "getRandomValues");
-        dialogManager.openWithExplicitCancel.mockResolvedValueOnce(true);
-
-        await manager.onConfirmApplySettingsFromWizard(
-            {
-                ...setting.currentSettings(),
-                userHashSalt: "00112233445566778899aabbccddeeff",
-            },
-            UserMode.NewUser
-        );
-
-        expect(setting.currentSettings().userHashSalt).toBe("00112233445566778899aabbccddeeff");
-        expect(randomSpy).not.toHaveBeenCalled();
-        expect(core.rebuilder.scheduleRebuild).toHaveBeenCalledTimes(1);
-        randomSpy.mockRestore();
-    });
 });

src/modules/features/SetupWizard/dialogs/FetchEverything.svelte

@@ -1,47 +1,30 @@
 <script lang="ts">
-    import DialogHeader from "@/lib/src/UI/components/DialogHeader.svelte";
-    import Guidance from "@/lib/src/UI/components/Guidance.svelte";
-    import Decision from "@/lib/src/UI/components/Decision.svelte";
-    import Question from "@/lib/src/UI/components/Question.svelte";
-    import Option from "@/lib/src/UI/components/Option.svelte";
-    import Options from "@/lib/src/UI/components/Options.svelte";
-    import Instruction from "@/lib/src/UI/components/Instruction.svelte";
-    import UserDecisions from "@/lib/src/UI/components/UserDecisions.svelte";
-    import InfoNote from "@/lib/src/UI/components/InfoNote.svelte";
-    import ExtraItems from "@/lib/src/UI/components/ExtraItems.svelte";
-    import Check from "@/lib/src/UI/components/Check.svelte";
-    const TYPE_IDENTICAL = "identical";
-    const TYPE_INDEPENDENT = "independent";
-    const TYPE_UNBALANCED = "unbalanced";
-    const TYPE_CANCEL = "cancelled";
+    import DialogHeader from "@lib/UI/components/DialogHeader.svelte";
+    import Guidance from "@lib/UI/components/Guidance.svelte";
+    import Decision from "@lib/UI/components/Decision.svelte";
+    import Question from "@lib/UI/components/Question.svelte";
+    import Option from "@lib/UI/components/Option.svelte";
+    import Options from "@lib/UI/components/Options.svelte";
+    import Instruction from "@lib/UI/components/Instruction.svelte";
+    import UserDecisions from "@lib/UI/components/UserDecisions.svelte";
+    import InfoNote from "@lib/UI/components/InfoNote.svelte";
+    import ExtraItems from "@lib/UI/components/ExtraItems.svelte";
+    import Check from "@lib/UI/components/Check.svelte";
+    import {
+        TYPE_BACKUP_DONE,
+        TYPE_BACKUP_SKIPPED,
+        TYPE_CANCEL,
+        TYPE_IDENTICAL,
+        TYPE_INDEPENDENT,
+        TYPE_UNABLE_TO_BACKUP,
+        TYPE_UNBALANCED,
+        type FetchEverythingResult,
+        type ResultTypeBackup,
+        type ResultTypeVault,
+    } from "./setupDialogTypes";
 
-    const TYPE_BACKUP_DONE = "backup_done";
-    const TYPE_BACKUP_SKIPPED = "backup_skipped";
-    const TYPE_UNABLE_TO_BACKUP = "unable_to_backup";
-
-    type ResultTypeVault =
-        | typeof TYPE_IDENTICAL
-        | typeof TYPE_INDEPENDENT
-        | typeof TYPE_UNBALANCED
-        | typeof TYPE_CANCEL;
-    type ResultTypeBackup =
-        | typeof TYPE_BACKUP_DONE
-        | typeof TYPE_BACKUP_SKIPPED
-        | typeof TYPE_UNABLE_TO_BACKUP
-        | typeof TYPE_CANCEL;
-
-    type ResultTypeExtra = {
-        preventFetchingConfig: boolean;
-    };
-    type ResultType =
-        | {
-              vault: ResultTypeVault;
-              backup: ResultTypeBackup;
-              extra: ResultTypeExtra;
-          }
-        | typeof TYPE_CANCEL;
     type Props = {
-        setResult: (result: ResultType) => void;
+        setResult: (result: FetchEverythingResult) => void;
     };
     const { setResult }: Props = $props();
     let vaultType = $state<ResultTypeVault>(TYPE_CANCEL);

src/modules/features/SetupWizard/dialogs/Intro.svelte

@@ -1,21 +1,19 @@
 <script lang="ts">
-    import DialogHeader from "@/lib/src/UI/components/DialogHeader.svelte";
-    import Guidance from "@/lib/src/UI/components/Guidance.svelte";
-    import Decision from "@/lib/src/UI/components/Decision.svelte";
-    import Question from "@/lib/src/UI/components/Question.svelte";
-    import Option from "@/lib/src/UI/components/Option.svelte";
-    import Options from "@/lib/src/UI/components/Options.svelte";
-    import Instruction from "@/lib/src/UI/components/Instruction.svelte";
-    import UserDecisions from "@/lib/src/UI/components/UserDecisions.svelte";
-    const TYPE_NEW_USER = "new-user";
-    const TYPE_EXISTING_USER = "existing-user";
-    const TYPE_CANCELLED = "cancelled";
-    type ResultType = typeof TYPE_NEW_USER | typeof TYPE_EXISTING_USER | typeof TYPE_CANCELLED;
+    import DialogHeader from "@lib/UI/components/DialogHeader.svelte";
+    import Guidance from "@lib/UI/components/Guidance.svelte";
+    import Decision from "@lib/UI/components/Decision.svelte";
+    import Question from "@lib/UI/components/Question.svelte";
+    import Option from "@lib/UI/components/Option.svelte";
+    import Options from "@lib/UI/components/Options.svelte";
+    import Instruction from "@lib/UI/components/Instruction.svelte";
+    import UserDecisions from "@lib/UI/components/UserDecisions.svelte";
+    import { TYPE_NEW_USER, TYPE_EXISTING_USER, TYPE_CANCELLED, type IntroResultType } from "./setupDialogTypes";
+
     type Props = {
-        setResult: (result: ResultType) => void;
+        setResult: (result: IntroResultType) => void;
     };
     const { setResult }: Props = $props();
-    let userType = $state<ResultType>(TYPE_CANCELLED);
+    let userType = $state<IntroResultType>(TYPE_CANCELLED);
     let proceedTitle = $derived.by(() => {
         if (userType === TYPE_NEW_USER) {
             return "Yes, I want to set up a new synchronisation";

src/modules/features/SetupWizard/dialogs/OutroAskUserMode.svelte

@@ -7,16 +7,19 @@
     import Instruction from "@/lib/src/UI/components/Instruction.svelte";
     import UserDecisions from "@/lib/src/UI/components/UserDecisions.svelte";
     import InfoNote from "@/lib/src/UI/components/InfoNote.svelte";
-    const TYPE_EXISTING = "existing-user";
-    const TYPE_NEW = "new-user";
-    const TYPE_COMPATIBLE_EXISTING = "compatible-existing-user";
-    const TYPE_CANCELLED = "cancelled";
-    type ResultType = typeof TYPE_EXISTING | typeof TYPE_NEW | typeof TYPE_COMPATIBLE_EXISTING | typeof TYPE_CANCELLED;
+    import {
+        type OutroAskUserModeResultType,
+        TYPE_CANCELLED,
+        TYPE_EXISTING,
+        TYPE_NEW,
+        TYPE_COMPATIBLE_EXISTING,
+    } from "./setupDialogTypes";
+
     type Props = {
-        setResult: (result: ResultType) => void;
+        setResult: (result: OutroAskUserModeResultType) => void;
     };
     const { setResult }: Props = $props();
-    let userType = $state<ResultType>(TYPE_CANCELLED);
+    let userType = $state<OutroAskUserModeResultType>(TYPE_CANCELLED);
     const canProceed = $derived.by(() => {
         return userType === TYPE_EXISTING || userType === TYPE_NEW || userType === TYPE_COMPATIBLE_EXISTING;
     });
@@ -41,7 +44,11 @@
 </Guidance>
 <Instruction>
     <Question>Please select your situation.</Question>
-    <Option title="I am setting up a new server for the first time / I want to reset my existing server." bind:value={userType} selectedValue={TYPE_NEW}>
+    <Option
+        title="I am setting up a new server for the first time / I want to reset my existing server."
+        bind:value={userType}
+        selectedValue={TYPE_NEW}
+    >
         <InfoNote>
             Selecting this option will result in the current data on this device being used to initialise the server.
             Any existing data on the server will be completely overwritten.