Revise devs note

Revise redflag.md option descriptions
Updated descriptions for redflag options in troubleshooting documentation.
2026-06-03 09:01:52 +03:00 · 2026-06-03 01:13:50 +00:00 · 2026-06-02 21:14:42 +09:00 · 2026-05-25 18:38:04 +09:00 · 2026-05-25 10:14:18 +01:00 · 2026-05-25 10:10:46 +01:00
24 changed files with 1564 additions and 202 deletions
--- a/.github/workflows/release.yml
+++ b/.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:
--- a/.github/workflows/unit-ci.yml
+++ b/.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'
--- a/devs.md
+++ b/devs.md
@@ -3,6 +3,76 @@

 Self-hosted LiveSync is an Obsidian plugin for synchronising vaults across devices using CouchDB, MinIO/S3, or peer-to-peer WebRTC. The codebase uses a modular architecture with TypeScript, Svelte, and PouchDB.

+## Build & Development Workflow
+
+### Environment Setup
+
+#### First-time Setup
+
+This repository uses submodules by convention. Therefore, you must use the `--recursive` flag when cloning it.
+```bash
+git clone --recursive https://github.com/vrtmrz/obsidian-livesync
+npm ci
+npm run build
+```
+
+Note: if you already cloned without submodules, run: `git submodule update --init --recursive`
+
+#### Branch switching
+When switching branches, please make sure to update submodules as well, since they may be updated in the new branch.
+```bash
+git checkout --recurse-submodules 0.25.70-patch1 # tag or branch name
+npm ci
+npm run build
+```
+
+### Commands
+
+```bash
+npm run test:unit    # Run unit tests with vitest (or `npm run test:unit:coverage` for coverage)
+npm run check        # TypeScript and svelte type checking
+npm run dev          # Development build with auto-rebuild (uses .env for test vault paths)
+npm run build        # Production build
+npm run buildDev     # Development build (one-time)
+npm run bakei18n     # Pre-build step: compile i18n resources (YAML → JSON → TS)
+npm run test:unit    # Run unit tests only (no Docker services required)
+npm test             # Run Harness based vitest tests (requires Docker services), not recommended, unstable.
+```
+
+### Tips
+
+We can use CLI's E2E test command instead of `npm test`.
+
+### Auto-copy to test vaults
+
+To facilitate development and testing, the build process can automatically copy the built plugin to specified test vault
+
+- 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 whilst `npm run dev` is running (watch mode)
+
+### Testing Infrastructure
+
+- ~~**Deno Tests**: Unit tests for platform-independent code (e.g., `HashManager.test.ts`)~~
+    - This is now obsolete, migrated to vitest.
+- **Vitest** (`vitest.config.ts`): E2E test by Browser-based-harness using Playwright, unit tests.
+    - Unit tests should be `*.unit.spec.ts` and placed alongside the implementation file (e.g., `ChunkFetcher.unit.spec.ts`).
+
+- **Docker Services**: Tests require CouchDB, MinIO (S3), and P2P services:
+    ```bash
+    npm run test:docker-all:start  # Start all test services
+    npm run test:full              # Run tests with coverage
+    npm run test:docker-all:stop   # Stop services
+    ```
+    If some services are not needed, start only required ones (e.g., `test:docker-couchdb:start`)
+    Note that if services are already running, starting script will fail. Please stop them first.
+
+- **Test Structure**:
+    - `test/suite/` - Integration tests for sync operations
+    - `test/unit/` - Unit tests (via vitest, as harness is browser-based)
+    - `test/harness/` - Mock implementations (e.g., `obsidian-mock.ts`)
+
+
+
 ## Architecture

 ### Module System
@@ -47,48 +117,6 @@ Hence, the new feature should be implemented as follows:
 - **Development code**: Use `.dev.ts` suffix (replaced with `.prod.ts` in production)
 - **Path aliases**: `@/*` maps to `src/*`, `@lib/*` maps to `src/lib/src/*`

-## Build & Development Workflow
-
-### Commands
-
-```bash
-npm run test:unit    # Run unit tests with vitest (or `npm run test:unit:coverage` for coverage)
-npm run check        # TypeScript and svelte type checking
-npm run dev          # Development build with auto-rebuild (uses .env for test vault paths)
-npm run build        # Production build
-npm run buildDev     # Development build (one-time)
-npm run bakei18n     # Pre-build step: compile i18n resources (YAML → JSON → TS)
-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
-
-### Testing Infrastructure
-
- ~~**Deno Tests**: Unit tests for platform-independent code (e.g., `HashManager.test.ts`)~~
-    - This is now obsolete, migrated to vitest.
- **Vitest** (`vitest.config.ts`): E2E test by Browser-based-harness using Playwright, unit tests.
-    - Unit tests should be `*.unit.spec.ts` and placed alongside the implementation file (e.g., `ChunkFetcher.unit.spec.ts`).
-
- **Docker Services**: Tests require CouchDB, MinIO (S3), and P2P services:
-    ```bash
-    npm run test:docker-all:start  # Start all test services
-    npm run test:full              # Run tests with coverage
-    npm run test:docker-all:stop   # Stop services
-    ```
-    If some services are not needed, start only required ones (e.g., `test:docker-couchdb:start`)
-    Note that if services are already running, starting script will fail. Please stop them first.
- **Test Structure**:
-    - `test/suite/` - Integration tests for sync operations
-    - `test/unit/` - Unit tests (via vitest, as harness is browser-based)
-    - `test/harness/` - Mock implementations (e.g., `obsidian-mock.ts`)
-
 ## Code Conventions

 ### Internationalisation (i18n)
@@ -156,17 +184,17 @@ export class ModuleExample extends AbstractObsidianModule {

 ## Beta Policy

- Beta versions are denoted by appending `+patchedN` to the base version number.
+- Beta versions are denoted by appending `-patchedN` to the base version number.
    - `The base version` mostly corresponds to the stable release version.
-        - e.g., v0.25.41+patched1 is equivalent to v0.25.42-beta1.
+        - e.g., v0.25.41-patched1 is equivalent to v0.25.42-beta1.
    - This notation is due to SemVer incompatibility of Obsidian's plugin system.
-    - Hence, this release is `0.25.41+patched1`.
+    - Hence, this release is `0.25.41-patched1`.
 - Each beta version may include larger changes, but bug fixes will often not be included.
    - I think that in most cases, bug fixes will cause the stable releases.
    - They will not be released per branch or backported; they will simply be released.
    - Bug fixes for previous versions will be applied to the latest beta version.
-      This means, if xx.yy.02+patched1 exists and there is a defect in xx.yy.01, a fix is applied to xx.yy.02+patched1 and yields xx.yy.02+patched2.
-      If the fix is required immediately, it is released as xx.yy.02 (with xx.yy.01+patched1).
+      This means, if xx.yy.02-patched1 exists and there is a defect in xx.yy.01, a fix is applied to xx.yy.02-patched1 and yields xx.yy.02-patched2.
+      If the fix is required immediately, it is released as xx.yy.02 (with xx.yy.01-patched1).
    - This procedure remains unchanged from the current one.
 - At the very least, I am using the latest beta.
    - However, I will not be using a beta continuously for a week after it has been released. It is probably closer to an RC in nature.
--- a/docs/troubleshooting.md
+++ b/docs/troubleshooting.md
@@ -382,11 +382,11 @@ This file is in Markdown format so that it can be placed in the Vault externally

 There are some options to use `redflag.md`.

-| Filename      | Human-Friendly Name | Description                                                                          |
-| ------------- | ------------------- | ------------------------------------------------------------------------------------ |
-| `redflag.md`  | -                   | Suspends all processes.                                                              |
-| `redflag2.md` | `flag_rebuild.md`   | Suspends all processes, and rebuild both local and remote databases by local files.  |
-| `redflag3.md` | `flag_fetch.md`     | Suspends all processes, discard the local database, and fetch from the remote again. |
+| Filename      | Human-Friendly Name | Description                                                                             |
+| ------------- | ------------------- | --------------------------------------------------------------------------------------- |
+| `redflag.md`  | -                   | Suspends all processes.                                                                 |
+| `redflag2.md` | `flag_rebuild.md`   | Suspends all processes, and rebuilds both local and remote databases from local files.  |
+| `redflag3.md` | `flag_fetch.md`     | Suspends all processes, discards the local database, and fetches from the remote again. |

 When fetching everything remotely or performing a rebuild, restarting Obsidian
 is performed once for safety reasons. At that time, Self-hosted LiveSync uses
@@ -399,6 +399,16 @@ these files are also not subject to synchronisation.
 However, occasionally the deletion of files may fail. This should generally work
 normally after restarting Obsidian. (As far as I can observe).

+>[!IMPORTANT]
+> When a flag file is detected, all synchronisation is disabled, and `Suspend file watching` and
+> `Suspend database reflecting` are enabled automatically. Therefore, please follow the steps below to
+> resolve the issue.
+> 1. Delete the flag file.
+> 2. Shutdown Obsidian.
+> 3. Check your vault folder and ensure it is no longer there.
+> 4. Launch Obsidian.
+> 5. Disable `Suspend file watching` and `Suspend database reflecting` in the settings dialogue (if you have not been asked).
+
 ### Old tips

 - Rarely, a file in the database could be corrupted. The plugin will not write
--- a/manifest.json
+++ b/manifest.json
@@ -1,10 +1,10 @@
 {
    "id": "obsidian-livesync",
    "name": "Self-hosted LiveSync",
-    "version": "0.25.65",
+    "version": "0.25.70",
    "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",
    "isDesktopOnly": false
-}
+}
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
    "name": "obsidian-livesync",
-    "version": "0.25.65",
+    "version": "0.25.70",
    "lockfileVersion": 3,
    "requires": true,
    "packages": {
        "": {
            "name": "obsidian-livesync",
-            "version": "0.25.65",
+            "version": "0.25.70",
            "license": "MIT",
            "dependencies": {
                "@aws-sdk/client-s3": "^3.808.0",
@@ -15,7 +15,7 @@
                "@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",
+                "@trystero-p2p/nostr": "^0.24.0",
                "chokidar": "^4.0.0",
                "commander": "^14.0.3",
                "diff-match-patch": "^1.0.5",
@@ -28,7 +28,7 @@
                "octagonal-wheels": "^0.1.45",
                "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"
            },
            "devDependencies": {
@@ -2684,9 +2684,9 @@
            }
        },
        "node_modules/@noble/secp256k1": {
-            "version": "3.0.0",
-            "resolved": "https://registry.npmjs.org/@noble/secp256k1/-/secp256k1-3.0.0.tgz",
-            "integrity": "sha512-NJBaR352KyIvj3t6sgT/+7xrNyF9Xk9QlLSIqUGVUYlsnDTAUqY8LOmwpcgEx4AMJXRITQ5XEVHD+mMaPfr3mg==",
+            "version": "3.1.0",
+            "resolved": "https://registry.npmjs.org/@noble/secp256k1/-/secp256k1-3.1.0.tgz",
+            "integrity": "sha512-+F7iS7tUMaNGXcc9X3PjmjvuQnXEuSjCRNzVVA2xAcKXgCaP0dHYz4SFyt4FKNHef7sOP//xihowcySSS7PK9g==",
            "license": "MIT",
            "funding": {
                "url": "https://paulmillr.com/funding/"
@@ -4297,19 +4297,19 @@
            "license": "MIT"
        },
        "node_modules/@trystero-p2p/core": {
-            "version": "0.23.0",
-            "resolved": "https://registry.npmjs.org/@trystero-p2p/core/-/core-0.23.0.tgz",
-            "integrity": "sha512-ozhtgxKDZH11Gdef0wH8xivwAE/L0/lDFvEcNFWPJWnHZlxWPPyfeonwE287ssGevQNi10vnj6x2ZcOi0n1bQQ==",
+            "version": "0.24.0",
+            "resolved": "https://registry.npmjs.org/@trystero-p2p/core/-/core-0.24.0.tgz",
+            "integrity": "sha512-W5ATiflgzZLE21fN2VA3YsK2yBJEzCvhmJ/9q2Vm3QT/gcdqDpcBxsO0DYCy/wE1PBEwoB+A75eBNtGIGAPdxw==",
            "license": "MIT"
        },
        "node_modules/@trystero-p2p/nostr": {
-            "version": "0.23.0",
-            "resolved": "https://registry.npmjs.org/@trystero-p2p/nostr/-/nostr-0.23.0.tgz",
-            "integrity": "sha512-KSqUR2c1KVfv4zeErcntuegtyKzFTzNNiitIKGD0LiKA/4H3CeTF81ROk2h+X/PNvP4mv7Gp5eVxFYwfMu4Nrg==",
+            "version": "0.24.0",
+            "resolved": "https://registry.npmjs.org/@trystero-p2p/nostr/-/nostr-0.24.0.tgz",
+            "integrity": "sha512-LmsJSicsFU/rhmOWYaP/OxFl3rwGieX+q0eh0pAWUQM7IXbMu6tLC5+aAimtHitikPv9r6sck6EUTWMin8dBAw==",
            "license": "MIT",
            "dependencies": {
-                "@noble/secp256k1": "^3.0.0",
-                "@trystero-p2p/core": "0.23.0"
+                "@noble/secp256k1": "^3.1.0",
+                "@trystero-p2p/core": "0.24.0"
            }
        },
        "node_modules/@tsconfig/svelte": {
@@ -16291,9 +16291,9 @@
            "license": "BSD-2-Clause"
        },
        "node_modules/werift": {
-            "version": "0.22.9",
-            "resolved": "https://registry.npmjs.org/werift/-/werift-0.22.9.tgz",
-            "integrity": "sha512-TE9AxskSRWBMYm0MBRllfnKVXQelqC76JCvyolQyVWpmKabfY5BA/cuvkGg+71JWn3QrGih1YWtpIWGPqoxcoA==",
+            "version": "0.23.0",
+            "resolved": "https://registry.npmjs.org/werift/-/werift-0.23.0.tgz",
+            "integrity": "sha512-/WcIN5DHFG9Ri4anGOmIkp8gxBGFMWSIB/m4sfZ5CWlLfD3iMhiaAUuTBuc+KV3SY9NDmvmLtiN2uaM7k3lVzw==",
            "license": "MIT",
            "dependencies": {
                "@fidm/x509": "^1.2.1",
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
    "name": "obsidian-livesync",
-    "version": "0.25.65",
+    "version": "0.25.70",
    "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",
@@ -130,7 +130,7 @@
        "@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",
+        "@trystero-p2p/nostr": "^0.24.0",
        "chokidar": "^4.0.0",
        "commander": "^14.0.3",
        "obsidian": "^1.12.3",
@@ -143,7 +143,7 @@
        "octagonal-wheels": "^0.1.45",
        "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"
    }
 }
--- a/src/apps/cli/README.md
+++ b/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
@@ -252,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
--- a/src/apps/cli/commands/runCommand.ts
+++ b/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,6 +12,10 @@ 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;

@@ -469,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}`);
 }
--- a/src/apps/cli/commands/runCommand.unit.spec.ts
+++ b/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);
+    });
 });
--- a/src/apps/cli/commands/types.ts
+++ b/src/apps/cli/commands/types.ts
@@ -20,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 {
@@ -67,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);
--- a/src/apps/cli/main.ts
+++ b/src/apps/cli/main.ts
@@ -62,6 +62,16 @@ 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
@@ -84,6 +94,12 @@ Examples:
    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
        `);
@@ -229,6 +245,9 @@ export async function main() {
        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" ||
--- a/src/apps/cli/main.unit.spec.ts
+++ b/src/apps/cli/main.unit.spec.ts
@@ -86,6 +86,56 @@ describe("CLI parseArgs", () => {
        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();
--- a/src/features/P2PSync/P2PReplicator/P2PServerStatusCard.svelte
+++ b/src/features/P2PSync/P2PReplicator/P2PServerStatusCard.svelte
@@ -24,6 +24,7 @@
    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());
@@ -48,6 +49,18 @@
        }
    }

+    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;
@@ -58,6 +71,7 @@
        });
        const unsubscribeSettings = eventHub.onEvent(EVENT_SETTING_SAVED, (settings) => {
            roomSuffix = extractP2PRoomSuffix(settings?.P2P_roomID ?? "");
+            useDiagRTC = settings?.P2P_useDiagRTC ?? false;
        });

        fireAndForget(async () => {
@@ -131,6 +145,48 @@
        </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>
@@ -190,6 +246,11 @@
        margin-top: 0.25rem;
    }

+    .diag-toggle-row {
+        align-items: center;
+        margin-top: 0.25rem;
+    }
+
    .broadcast-label {
        font-size: 0.9rem;
        color: var(--text-normal);
@@ -221,4 +282,29 @@
        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>
--- a/src/lib
+++ b/src/lib
--- a/src/modules/coreFeatures/ModuleResolveMismatchedTweaks.ts
+++ b/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,
@@ -16,7 +18,105 @@ import type { InjectableServiceHub } from "../../lib/src/services/InjectableServ
 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;
@@ -27,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;
@@ -69,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),
                })
            );
        }
@@ -137,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) {
@@ -147,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) {
@@ -160,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";
@@ -201,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;
@@ -211,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;
@@ -289,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)
--- a/src/modules/coreFeatures/ModuleResolveMismatchedTweaks.unit.spec.ts
+++ b/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();
+    });
+});
--- a/src/modules/features/DocumentHistory/DocumentHistoryModal.ts
+++ b/src/modules/features/DocumentHistory/DocumentHistoryModal.ts
@@ -56,6 +56,7 @@ export class DocumentHistoryModal extends Modal {
    info!: HTMLDivElement;
    fileInfo!: HTMLDivElement;
    showDiff = false;
+    diffOnly = false;
    id?: DocumentID;

    file: FilePathWithPrefix;
@@ -70,6 +71,15 @@ export class DocumentHistoryModal extends Modal {
    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,
@@ -88,9 +98,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) {
@@ -151,17 +164,48 @@ export class DocumentHistoryModal extends Modal {
    }

    appendTextDiff(diff: [number, string][]) {
+        let hasOmitted = false;
        for (const [operation, text] of diff) {
            if (operation == DIFF_DELETE) {
-                this.contentView.createSpan({ text, cls: "history-deleted" });
+                this.appendSearchHighlightedText(this.contentView.createSpan({ cls: "history-deleted" }), text);
+                hasOmitted = false;
            } else if (operation == DIFF_EQUAL) {
-                this.contentView.createSpan({ text, cls: "history-normal" });
+                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.contentView.createSpan({ text, cls: "history-added" });
+                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" });
@@ -258,7 +302,7 @@ export class DocumentHistoryModal extends Modal {
                    if (this.currentDeleted) {
                        this.appendDeletedNotice();
                    }
-                    this.contentView.appendText(w1data);
+                    this.appendSearchHighlightedText(this.contentView, w1data);
                }
            }
        }
@@ -266,6 +310,11 @@ export class DocumentHistoryModal extends Modal {
        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" });
+            }
        }
    }

@@ -293,7 +342,7 @@ export class DocumentHistoryModal extends Modal {
        target.classList.add("diff-focused");
        target.scrollIntoView({ behavior: "smooth", block: "center" });

-        this.diffNavIndicator.textContent = `${this.currentDiffIndex + 1}/${diffElements.length}`;
+        this.diffNavIndicator.setText(`${this.currentDiffIndex + 1}/${diffElements.length}`);
    }

    /**
@@ -304,9 +353,9 @@ export class DocumentHistoryModal extends Modal {
        if (this.diffNavIndicator) {
            if (this.showDiff) {
                const diffElements = this.contentView.querySelectorAll(".history-added, .history-deleted");
-                this.diffNavIndicator.textContent = diffElements.length > 0 ? `0/${diffElements.length}` : "\u2014";
+                this.diffNavIndicator.setText(diffElements.length > 0 ? `0/${diffElements.length}` : "\u2014");
            } else {
-                this.diffNavIndicator.textContent = "\u2014";
+                this.diffNavIndicator.setText("\u2014");
            }
        }
        this.updateDiffNavVisibility();
@@ -319,6 +368,117 @@ export class DocumentHistoryModal extends Modal {
        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.
+        }
    }

    override onOpen() {
@@ -327,6 +487,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) {
+                clearTimeout(this.searchTimeout);
+            }
+            this.searchTimeout = window.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");

@@ -342,24 +538,43 @@ export class DocumentHistoryModal extends Modal {
        const diffOptionsRow = contentEl.createDiv("");
        diffOptionsRow.addClass("op-info");
        diffOptionsRow.addClass("diff-options-row");
+        diffOptionsRow.addClass("history-diff-options-row");

-        diffOptionsRow.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" : "");
-                        this.updateDiffNavVisibility();
-                        void scheduleOnceIfDuplicated("loadRevs", () => this.loadRevs());
-                    });
-                })
-            );
+        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());
+                });
+            });
            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");
--- a/src/modules/features/InteractiveConflictResolving/ConflictResolveModal.ts
+++ b/src/modules/features/InteractiveConflictResolving/ConflictResolveModal.ts
@@ -27,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);
@@ -47,7 +50,7 @@ export class ConflictResolveModal extends Modal {
        const lines = text.split("\n");
        lines.forEach((line, index) => {
            const span = container.createSpan({ cls });
-            span.textContent = line;
+            span.setText(line);
            if (index < lines.length - 1) {
                container.createSpan({ cls: "ls-mark-cr" });
                container.createEl("br");
@@ -62,6 +65,33 @@ export class ConflictResolveModal extends Modal {
        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
@@ -78,10 +108,26 @@ 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");
+        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];
@@ -91,12 +137,11 @@ export class ConflictResolveModal extends Modal {
                continue;
            }
            if (x1 == DIFF_DELETE) {
-                this.appendDiffFragment(div, x2, "deleted");
-                div.createEl("span", { text: x2, cls: "deleted normal conflict-dev-name" });
+                this.appendDiffFragment(this.diffView, x2, "deleted");
            } else if (x1 == DIFF_EQUAL) {
-                this.appendDiffFragment(div, x2, "normal");
+                this.appendDiffFragment(this.diffView, x2, "normal");
            } else if (x1 == DIFF_INSERT) {
-                this.appendDiffFragment(div, x2, "added");
+                this.appendDiffFragment(this.diffView, x2, "added");
            }
        }

@@ -108,24 +153,30 @@ export class ConflictResolveModal extends Modal {
            new Date(this.result.right.mtime).toLocaleString() + (this.result.right.deleted ? " (Deleted)" : "");
        this.appendVersionInfo(div2, "deleted", this.localName, date1);
        this.appendVersionInfo(div2, "added", this.remoteName, date2);
-        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";
+        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";
+        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) {
-            div.empty();
-            div.innerText = "(Too large diff to display)";
+            this.diffView.empty();
+            this.diffView.setText("(Too large diff to display)");
        }
+        this.resetDiffNavigation();
+        this.navigateDiff("next");
    }

    sendResponse(result: MergeDialogResult) {
--- a/src/modules/features/SettingDialogue/PaneAdvanced.ts
+++ b/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 })
--- a/src/modules/features/SetupManager.ts
+++ b/src/modules/features/SetupManager.ts
@@ -7,7 +7,7 @@ import {
    REMOTE_MINIO,
    REMOTE_P2P,
 } from "../../lib/src/common/types.ts";
-import { generatePatchObj, isObjectDifferent } from "../../lib/src/common/utils.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";
@@ -23,6 +23,7 @@ import SetupRemoteP2P from "./SetupWizard/dialogs/SetupRemoteP2P.svelte";
 import SetupRemoteE2EE from "./SetupWizard/dialogs/SetupRemoteE2EE.svelte";
 import { decodeSettingsFromQRCodeData } from "../../lib/src/API/processSetting.ts";
 import { AbstractModule } from "../AbstractModule.ts";
+import { ConnectionStringParser } from "@lib/common/ConnectionString.ts";

 /**
 * User modes for onboarding and setup
@@ -194,8 +195,24 @@ export class SetupManager extends AbstractModule {
            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);
    }
@@ -285,9 +302,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);
--- a/styles.css
+++ b/styles.css
@@ -17,6 +17,10 @@
    min-width: 5em;
 }

+.conflict-action-button {
+    margin-right: 4px;
+}
+
 .op-scrollable {
    overflow-y: scroll;
    /* min-height: 280px; */
@@ -521,8 +525,48 @@ div.workspace-leaf-content[data-type=bases]  .livesync-status {
    text-align: center;
 }

+.diff-only-label {
+    margin-left: 10px;
+}
+
+.history-search-row {
+    display: flex;
+    gap: 5px;
+    align-items: center;
+    margin-bottom: 10px;
+}
+
+.history-search-input {
+    flex-grow: 1;
+}
+
+.history-search-result-indicator {
+    font-size: 0.8em;
+    min-width: 80px;
+}
+
+.history-search-progress-indicator {
+    font-size: 0.8em;
+    color: var(--text-muted);
+}
+
+.history-diff-options-row {
+    justify-content: space-between;
+}
+
+.history-highlight-diff-container,
+.history-highlight-diff-label {
+    display: flex;
+    align-items: center;
+}
+
+.history-highlight-diff-label {
+    gap: 4px;
+}
+
 .diff-focused {
    outline: 2px solid var(--interactive-accent);
    outline-offset: 1px;
    border-radius: 2px;
-}
+}
+
--- a/terser.config.mjs
+++ b/terser.config.mjs
@@ -34,11 +34,11 @@ const terserOption = {
        inline: false,
        join_vars: true,
        loops: true,
-        passes: 4,
+        passes: 1,
        reduce_vars: true,
        reduce_funcs: false,
        arrows: true,
-        collapse_vars: true,
+        collapse_vars: false,
        comparisons: true,
        //@ts-ignore
        lhs_constants: true,
--- a/updates.md
+++ b/updates.md
@@ -3,6 +3,57 @@ Since 19th July, 2025 (beta1 in 0.25.0-beta1, 13th July, 2025)

 The head note of 0.25 is now in [updates_old.md](https://github.com/vrtmrz/obsidian-livesync/blob/main/updates_old.md). Because 0.25 got a lot of updates, thankfully, compatibility is kept and we do not need breaking changes! In other words, when get enough stabled. The next version will be v1.0.0. Even though it my hope.

+## 0.25.70
+
+25th May, 2026
+
+### New features
+- Diff dialogue now has great tools to navigate and understand the differences, including:
+  - A checkbox to toggle the visibility of collapsed identical sections, making it easier to focus on the actual differences (PR #889).
+  - A search feature to find specific text in past revisions, and navigate revisions with search results highlighted in the dialogue (PR #890).
+
+- Conflict resolution dialogue now has a navigation feature to jump between conflicts (PR #891).
+
+Thank you so much to @SeleiXi for implementing these features!
+
+### Improved
+
+- More diagnostic information for P2P connections is now shown, including why a connection failure occurred and the current connection status.
+
+## 0.25.69
+
+22nd May, 2026
+
+### Fixed
+- No longer does the P2P passphrase mismatch cause a server shutdown.
+- Settings related to P2P synchronisation are now correctly applied on start-up and no longer reverted.
+
+### New features
+- Diagnostic P2P connection stats are now available.
+  - These stats indicate the number of connection trials, successes, and failures.
+
+## 0.25.68
+
+22nd May, 2026
+
+### Improved
+
+- P2P connections have improved slightly
+  - Upgrade to `trystero` v0.24.0, and fixes event handler assignment. This should fix some edge cases where P2P connections fail to establish or messages are not properly handled.
+  - Weaken terser options to avoid potential issues with minification that could cause runtime errors in some environments.
+
+## ~~0.25.66~~ 0.25.67
+
+20th May, 2026
+
+0.25.66 had a bug that the auto-accept logic for compatible but lossy mismatches was not working as intended.
+
+### New features
+- Implement an auto-accept compatible tweak setting and enhance the mismatch resolution logic.
+
+### Improved
+- Many messages related to tweak mismatch resolution have been updated for clarity.
+
 ## 0.25.65

 19th May, 2026
Author	SHA1	Message	Date
vorotamoroz	b57f34c15b	Revise devs note	2026-06-03 01:13:50 +00:00
vorotamoroz	b82fd9f04b	Revise redflag.md option descriptions Updated descriptions for redflag options in troubleshooting documentation.	2026-06-02 21:14:42 +09:00
vorotamoroz	8d3825abc9	Merge pull request #925 from vrtmrz/v0_25_70 Releasing v0.25.70	2026-05-25 18:38:04 +09:00
vorotamoroz	c5f9841b85	chore: fix grammatical error	2026-05-25 10:14:18 +01:00
vorotamoroz	d36d176d99	bump	2026-05-25 10:10:46 +01:00
vorotamoroz	38b2cf73ed	Update lib (forgot to include #942 )	2026-05-25 09:55:11 +01:00
vorotamoroz	40b15a6950	Merge pull request #924 from vrtmrz/p2p_add_fix_and_diag Improvements: More diagnostic information for P2P connections	2026-05-25 17:52:37 +09:00
vorotamoroz	e312bb7640	Merge pull request #891 from SeleiXi/feat/conflict-diff-jump feat: add diff navigation to conflict resolver	2026-05-25 17:51:49 +09:00
Ching Wing Kwok	852c0e6c13	Merge branch 'main' into feat/conflict-diff-jump	2026-05-25 15:38:21 +08:00
vorotamoroz	7c1bcf9e9b	Merge pull request #889 from SeleiXi/diff-only-button feat: add diff-only view button to document history	2026-05-25 14:00:11 +09:00
vorotamoroz	2b79bed085	Merge branch 'main' into pr/SeleiXi/889	2026-05-25 05:43:36 +01:00
vorotamoroz	6b1e0c4aa8	Merge pull request #890 from SeleiXi/feat/history-search feat: Add document history search	2026-05-25 12:55:29 +09:00
vorotamoroz	3c3645eba4	Improved: More diagnostic information for P2P connections is now shown, including why a connection failure occurred and the current connection status.	2026-05-25 04:31:22 +01:00
SeleiXi	009cc3c87a	Merge remote-tracking branch 'origin/main' into feat/conflict-diff-jump # Conflicts: # src/modules/features/InteractiveConflictResolving/ConflictResolveModal.ts	2026-05-23 02:06:52 +08:00
SeleiXi	fc5fd4be94	Merge remote-tracking branch 'origin/main' into feat/history-search # Conflicts: # src/lib # src/modules/features/DocumentHistory/DocumentHistoryModal.ts	2026-05-23 02:05:33 +08:00
SeleiXi	8ed1acf79d	Merge remote-tracking branch 'origin/main' into diff-only-button # Conflicts: # src/modules/features/DocumentHistory/DocumentHistoryModal.ts	2026-05-23 02:04:48 +08:00
vorotamoroz	c518223d21	Merge pull request #923 from vrtmrz/p2p_add_fix_and_diag 0.25.69: Fix P2P, add diag feature	2026-05-23 00:47:36 +09:00
vorotamoroz	caaff618e9	fix grammar	2026-05-22 16:40:40 +01:00
vorotamoroz	148aa8505e	bump	2026-05-22 16:38:44 +01:00
vorotamoroz	f9a626a858	### Fixed - No longer the P2P passphrase mismatch causes a server shutdown. - Settings related to P2P synchronisation are now correctly applied on start-up and no longer reverted. ### New features - Diagnostic P2P connection stats are now available. - These stats indicate the number of connection trials, successes, and, failures.	2026-05-22 16:37:05 +01:00
vorotamoroz	1b8747115c	Merge pull request #922 from vrtmrz/update_trystero Releasing v0.25.68 (dependency and P2P update)	2026-05-22 19:17:22 +09:00
vorotamoroz	e739302fb9	bump	2026-05-22 11:11:18 +01:00
vorotamoroz	8f20d53f55	Update trystero, typed well. fixed some potentially problems Weaken terser for libraries	2026-05-22 11:01:51 +01:00
vorotamoroz	fd84b0377b	Update actions	2026-05-21 10:02:46 +01:00
vorotamoroz	340d416b76	Merge pull request #920 from vrtmrz/v0_25_66 Release v0.25.67	2026-05-20 19:44:41 +09:00
vorotamoroz	3034af8d69	bump again	2026-05-20 11:37:51 +01:00
vorotamoroz	da3020bd45	fixed: fix auto-correction mismatch	2026-05-20 11:34:28 +01:00
vorotamoroz	ce232c1002	bump	2026-05-20 11:14:41 +01:00
vorotamoroz	0e13926400	fixed: update lib I should do this with #919	2026-05-20 11:10:43 +01:00
vorotamoroz	fab7ec996a	Merge pull request #919 from vrtmrz:feat_cli_remote_select feat: add CLI commands to handle multiple remote configuration	2026-05-20 19:05:49 +09:00
vorotamoroz	88e22f99c5	Merge pull request #917 from vrtmrz:feat_tweak_auto_adjust feat: implement auto-accept compatible tweak	2026-05-20 19:02:58 +09:00
vorotamoroz	83cbabf06f	Merge branch 'main' into feat_tweak_auto_adjust	2026-05-20 11:01:51 +01:00
vorotamoroz	5e8d3b8f02	Update lib	2026-05-20 11:00:38 +01:00
vorotamoroz	1167b41340	feat: add CLI commands to handle multiple remote configuration	2026-05-20 05:10:42 +01:00
vorotamoroz	e8c33a0d6a	feat: implement auto-accept compatible tweak setting and enhance mismatch resolution logic	2026-05-18 11:21:53 +01:00
SeleiXi	5454e1106f	feat: add diff navigation to conflict resolver	2026-05-13 00:19:56 +08:00
SeleiXi	0d9397c8b9	fix: resolve UI alignment issue for diff navigation buttons	2026-05-12 00:52:20 +08:00
SeleiXi	429a3ff1fd	feat: add diff-only view button to document history	2026-05-11 23:53:07 +08:00
SeleiXi	bfff6ea7b8	feat: add document history search support	2026-05-11 22:45:42 +08:00