Merge remote-tracking branch 'origin/main' into cli_test_deno

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

@@ -32,13 +32,13 @@ jobs:
 
           case "$SELECTED_TASK" in
             test)
-              TASK_MATRIX='["test:setup-put-cat","test:mirror","test:push-pull","test:sync-two-local","test:sync-locked-remote","test:p2p-host","test:p2p-peers","test:p2p-sync","test:p2p-three-nodes","test:p2p-upload-download","test:e2e-couchdb","test:e2e-matrix"]'
+              TASK_MATRIX='["test:setup-put-cat","test:mirror","test:push-pull","test:sync-two-local","test:sync-locked-remote","test:p2p-host","test:p2p-peers","test:p2p-sync","test:p2p-three-nodes","test:p2p-upload-download","test:e2e-matrix:couchdb-enc0","test:e2e-matrix:couchdb-enc1","test:e2e-matrix:minio-enc0","test:e2e-matrix:minio-enc1"]'
               ;;
             test:local)
               TASK_MATRIX='["test:setup-put-cat","test:mirror"]'
               ;;
             test:e2e-matrix)
-              TASK_MATRIX='["test:e2e-matrix"]'
+              TASK_MATRIX='["test:e2e-matrix:couchdb-enc0","test:e2e-matrix:couchdb-enc1","test:e2e-matrix:minio-enc0","test:e2e-matrix:minio-enc1"]'
               ;;
             test:p2p-sync)
               TASK_MATRIX='["test:p2p-sync"]'
@@ -55,6 +55,8 @@ jobs:
     needs: prepare
     runs-on: ubuntu-latest
     timeout-minutes: 60
+    env:
+      DENO_DIR: ~/.cache/deno
     strategy:
       fail-fast: false
       matrix:
@@ -70,12 +72,21 @@ jobs:
         with:
           node-version: '24.x'
           cache: 'npm'
+          cache-dependency-path: package-lock.json
 
       - name: Setup Deno
         uses: denoland/setup-deno@v2
         with:
           deno-version: v2.x
 
+      - name: Cache Deno dependencies
+        uses: actions/cache@v4
+        with:
+          path: ~/.cache/deno
+          key: ${{ runner.os }}-deno-${{ hashFiles('src/apps/cli/testdeno/deno.lock', 'src/apps/cli/testdeno/deno.json') }}
+          restore-keys: |
+            ${{ runner.os }}-deno-
+
       - name: Install dependencies
         run: npm ci
 

.gitignore

@@ -30,5 +30,4 @@ cov_profile/**
 coverage
 src/apps/cli/dist/*
 _testdata/**
-utils/bench/splitResults.csv
-.eslintcache
+utils/bench/splitResults.csv

devs.md

@@ -17,7 +17,7 @@ The plugin uses a dynamic module system to reduce coupling and improve maintaina
     - `coreObsidian/` - Obsidian-specific core (e.g., `ModuleFileAccessObsidian`)
     - `essential/` - Required modules (e.g., `ModuleMigration`, `ModuleKeyValueDB`)
     - `features/` - Optional features (e.g., `ModuleLog`, `ModuleObsidianSettings`)
-    - `extras/` - Development/testing tools (e.g., `ModuleDev`, ~~`ModuleIntegratedTest`~~)
+    - `extras/` - Development/testing tools (e.g., `ModuleDev`, `ModuleIntegratedTest`)
 - **Services**: Core services (e.g., `database`, `replicator`, `storageAccess`) are registered in `ServiceHub` and accessed by modules. They provide an extension point for add new behaviour without modifying existing code.
     - For example, checks before the replication can be added to the `replication.onBeforeReplicate` handler, and the handlers can be return `false` to prevent replication-starting. `vault.isTargetFile` also can be used to prevent processing specific files.
 - **ServiceModule**: A new type of module that directly depends on services.

eslint.config.mjs

@@ -6,77 +6,66 @@ import * as sveltePlugin from "eslint-plugin-svelte";
 
 export default defineConfig([
     globalIgnores([
-        // Build outputs and legacy files
-        "**/build",
-        "**/main.js",
-        "**/.eslintrc.js.bak",
-        // Files from linked dependencies (those files should not exist for most people).
-        "modules/octagonal-wheels/dist/**/*",
-
-        // Sub-projects (Exclude from root linting as they have different environments)
-        "src/apps/**/*",
-
-        // Specific exclusions from common library (src/lib)
+        "**/node_modules/*",
+        "**/jest.config.js",
         "src/lib/coverage",
         "src/lib/browsertest",
+        "**/test.ts",
+        "**/tests.ts",
+        "**/**test.ts",
+        "**/**.test.ts",
+        "**/*.unit.spec.ts",
+        "**/esbuild.*.mjs",
+        "**/terser.*.mjs",
+        "**/node_modules",
+        "**/build",
+        "**/.eslintrc.js.bak",
+        "src/lib/src/patches/pouchdb-utils",
+        "**/esbuild.config.mjs",
+        "**/rollup.config.js",
+        "modules/octagonal-wheels/rollup.config.js",
+        "modules/octagonal-wheels/dist/**/*",
         "src/lib/test",
         "src/lib/_tools",
-        "src/lib/src/patches/pouchdb-utils",
         "src/lib/src/cli",
-        "src/lib/src/services/implements/browser/**",
-        "src/lib/src/services/implements/headless/**",
-        "src/lib/src/API",
-
-        // Config files and build scripts
-        "**/jest.config.js",
-        "**/rollup.config.js",
-        "**/esbuild.config.mjs",
-        "**/terser.*.mjs",
+        "**/main.js",
+        "src/apps/**/*",
         ".prettierrc.*.mjs",
         ".prettierrc.mjs",
         "*.config.mjs",
-
-        // Testing files (Simplified patterns)
-        "**/*.test.ts",
-        "**/*.unit.spec.ts",
-        "**/test.ts",
-        "**/tests.ts",
+        "src/apps/**/*",
+        "src/lib/src/services/implements/browser/**",
+        "src/lib/src/services/implements/headless/**",
+        "src/lib/src/API",
     ]),
     ...sveltePlugin.configs["flat/base"],
     ...obsidianmd.configs.recommended,
     {
         files: ["**/*.ts"],
         languageOptions: {
-            globals: { ...globals.browser, "PouchDB": "readonly" },
+            globals: { ...globals.browser },
             parser: tsParser,
             parserOptions: {
                 project: "./tsconfig.json",
             },
         },
         rules: {
-            // Base rules (turned off in favour of TS specific versions or explicitly disabled).
             "no-unused-vars": "off",
-            "no-unused-labels": "off",
-            "no-prototype-builtins": "off",
-            "require-await": "off",
-
-            // TypeScript specific rules
             "@typescript-eslint/no-unused-vars": ["error", { args: "none" }],
+            "no-unused-labels": "off",
             "@typescript-eslint/ban-ts-comment": "off",
+            "no-prototype-builtins": "off",
             "@typescript-eslint/no-empty-function": "off",
+            "require-await": "error",
+            "obsidianmd/rule-custom-message": "off", // Temporary
+            "obsidianmd/ui/sentence-case": "off", // Temporary
             "@typescript-eslint/require-await": "warn",
             "@typescript-eslint/no-misused-promises": "warn",
             "@typescript-eslint/no-floating-promises": "warn",
+            "no-async-promise-executor": "warn",
             "@typescript-eslint/no-explicit-any": "off",
             "@typescript-eslint/no-unnecessary-type-assertion": "error",
-
-            // General rules
-            "no-async-promise-executor": "warn",
             "no-constant-condition": ["error", { checkLoops: false }],
-
-            // Plugin specific overrides (Pending review)
-            "obsidianmd/rule-custom-message": "off",
-            "obsidianmd/ui/sentence-case": "off",
         },
     },
     {
@@ -88,7 +77,7 @@ export default defineConfig([
         },
         rules: {
             "no-unused-vars": ["error", { argsIgnorePattern: "^_", varsIgnorePattern: "^_" }],
-            "obsidianmd/no-plugin-as-component": "off",
+            "obsidianmd/no-plugin-as-component": "off", // Temporary
         },
-    }
+    },
 ]);

manifest.json

@@ -1,10 +1,10 @@
 {
     "id": "obsidian-livesync",
     "name": "Self-hosted LiveSync",
-    "version": "0.25.70",
+    "version": "0.25.68",
     "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
-}
+}

package-lock.json

@@ -1,12 +1,12 @@
 {
     "name": "obsidian-livesync",
-    "version": "0.25.70",
+    "version": "0.25.68",
     "lockfileVersion": 3,
     "requires": true,
     "packages": {
         "": {
             "name": "obsidian-livesync",
-            "version": "0.25.70",
+            "version": "0.25.68",
             "license": "MIT",
             "dependencies": {
                 "@aws-sdk/client-s3": "^3.808.0",

package.json

@@ -1,6 +1,6 @@
 {
     "name": "obsidian-livesync",
-    "version": "0.25.70",
+    "version": "0.25.68",
     "description": "Reflect your vault changes to some other devices immediately. Please make sure to disable other synchronize solutions to avoid content corruption or duplication.",
     "main": "main.js",
     "type": "module",
@@ -19,7 +19,7 @@
         "buildVite": "npx dotenv-cli -e .env  -- vite build --mode production",
         "buildViteOriginal": "npx dotenv-cli -e .env  -- vite build --mode original",
         "buildDev": "node esbuild.config.mjs dev",
-        "lint": "eslint --cache --concurrency auto src",
+        "lint": "eslint src",
         "svelte-check": "svelte-check --tsconfig ./tsconfig.json",
         "tsc-check": "tsc --noEmit",
         "pretty": "npm run prettyNoWrite -- --write --log-level error",

src/apps/cli/.gitignore

@@ -5,4 +5,5 @@ test/test-init.local.sh
 node_modules
 .*.json
 *.env
-!.test.env
+!.test.env
+bench-results

src/apps/cli/testdeno/bench-couchdb.ts

@@ -0,0 +1,312 @@
+import { TempDir } from "./helpers/temp.ts";
+import { applyRemoteSyncSettings, initSettingsFile } from "./helpers/settings.ts";
+import { assertFilesEqual, runCliOrFail } from "./helpers/cli.ts";
+import { startCouchdb, stopCouchdb } from "./helpers/docker.ts";
+import { createDeterministicDataset, type DatasetEntry } from "./helpers/dataset.ts";
+
+type BenchmarkConfig = {
+    couchdbBackendUri: string;
+    couchdbProxyUri: string;
+    couchdbUser: string;
+    couchdbPassword: string;
+    couchdbDbname: string;
+    datasetDirName: string;
+    datasetSeed: string;
+    mdFileCount: number;
+    mdMinSizeBytes: number;
+    mdMaxSizeBytes: number;
+    binFileCount: number;
+    binSizeBytes: number;
+    syncTimeoutSeconds: number;
+    requestedRttMs: number;
+    passphrase: string;
+    encrypt: boolean;
+};
+
+function readEnvString(name: string, fallback: string): string {
+    const value = Deno.env.get(name)?.trim();
+    return value && value.length > 0 ? value : fallback;
+}
+
+function readEnvNumber(name: string, fallback: number): number {
+    const raw = Deno.env.get(name);
+    if (raw === undefined || raw.trim() === "") {
+        return fallback;
+    }
+
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new Error(`${name} must be a positive number, got '${raw}'`);
+    }
+    return parsed;
+}
+
+function readEnvBool(name: string, fallback: boolean): boolean {
+    const raw = Deno.env.get(name);
+    if (raw === undefined || raw.trim() === "") {
+        return fallback;
+    }
+    return /^(1|true|yes|on)$/i.test(raw.trim());
+}
+
+function nowMs(): number {
+    return performance.now();
+}
+
+function formatMs(value: number): string {
+    return `${value.toFixed(1)} ms`;
+}
+
+function formatBytes(value: number): string {
+    if (value < 1024) {
+        return `${value} B`;
+    }
+    const kib = value / 1024;
+    if (kib < 1024) {
+        return `${kib.toFixed(1)} KiB`;
+    }
+    return `${(kib / 1024).toFixed(1)} MiB`;
+}
+
+function buildConfig(): BenchmarkConfig {
+    return {
+        couchdbBackendUri: readEnvString("BENCH_COUCHDB_BACKEND_URI", "http://127.0.0.1:5989"),
+        couchdbProxyUri: readEnvString("BENCH_COUCHDB_URI", "http://127.0.0.1:15989"),
+        couchdbUser: readEnvString("BENCH_COUCHDB_USER", readEnvString("username", "admin")),
+        couchdbPassword: readEnvString("BENCH_COUCHDB_PASSWORD", readEnvString("password", "password")),
+        couchdbDbname: readEnvString("BENCH_COUCHDB_DBNAME", `bench-couchdb-${Date.now()}`),
+        datasetDirName: readEnvString("BENCH_DATASET_DIR", "bench-dataset"),
+        datasetSeed: readEnvString("BENCH_SEED", "livesync-benchmark-seed"),
+        mdFileCount: Math.floor(readEnvNumber("BENCH_MD_FILE_COUNT", 1500)),
+        mdMinSizeBytes: Math.floor(readEnvNumber("BENCH_MD_MIN_SIZE_BYTES", 1024)),
+        mdMaxSizeBytes: Math.floor(readEnvNumber("BENCH_MD_MAX_SIZE_BYTES", 20 * 1024)),
+        binFileCount: Math.floor(readEnvNumber("BENCH_BIN_FILE_COUNT", 500)),
+        binSizeBytes: Math.floor(readEnvNumber("BENCH_BIN_SIZE_BYTES", 100 * 1024)),
+        syncTimeoutSeconds: readEnvNumber("BENCH_SYNC_TIMEOUT", 240),
+        requestedRttMs: Math.floor(readEnvNumber("BENCH_COUCHDB_RTT_MS", 50)),
+        passphrase: readEnvString("BENCH_PASSPHRASE", `bench-${Date.now()}`),
+        encrypt: readEnvBool("BENCH_ENCRYPT", true),
+    };
+}
+
+function readOptionalResultPath(): string | undefined {
+    const raw = Deno.env.get("BENCH_RESULT_JSON")?.trim();
+    if (!raw) {
+        return undefined;
+    }
+    return raw;
+}
+
+function pickSampleFiles(entries: DatasetEntry[]): DatasetEntry[] {
+    if (entries.length === 0) {
+        return [];
+    }
+    const md = entries.find((e) => e.kind === "md");
+    const bin = entries.find((e) => e.kind === "bin");
+    const middle = entries[Math.floor(entries.length / 2)];
+    const last = entries[entries.length - 1];
+    const unique = new Map<string, DatasetEntry>();
+    for (const entry of [md, bin, middle, last]) {
+        if (entry) {
+            unique.set(entry.relativePath, entry);
+        }
+    }
+    return [...unique.values()];
+}
+
+type ProxyHandle = {
+    stop: () => Promise<void>;
+    applied: boolean;
+    note: string;
+};
+
+function startCouchdbProxy(options: { backendUri: string; proxyUri: string; requestedRttMs: number }): ProxyHandle {
+    const backend = new URL(options.backendUri);
+    const proxy = new URL(options.proxyUri);
+    const halfDelayMs = Math.max(1, Math.floor(options.requestedRttMs / 2));
+    const controller = new AbortController();
+
+    const listener = Deno.serve(
+        {
+            hostname: proxy.hostname,
+            port: Number(proxy.port),
+            signal: controller.signal,
+            onError(error) {
+                console.error(`[Proxy] ${String(error)}`);
+                return new Response("proxy error", { status: 502 });
+            },
+        },
+        async (request) => {
+            await new Promise((resolve) => setTimeout(resolve, halfDelayMs));
+
+            const targetUrl = new URL(request.url);
+            targetUrl.protocol = backend.protocol;
+            targetUrl.host = backend.host;
+
+            const headers = new Headers(request.headers);
+            headers.delete("host");
+            headers.delete("content-length");
+
+            let requestBody: ArrayBuffer | undefined;
+            if (request.method !== "GET" && request.method !== "HEAD") {
+                try {
+                    requestBody = await request.arrayBuffer();
+                } catch {
+                    requestBody = undefined;
+                }
+            }
+
+            const upstream = await fetch(targetUrl, {
+                method: request.method,
+                headers,
+                body: requestBody,
+                redirect: "manual",
+            });
+
+            const responseHeaders = new Headers(upstream.headers);
+            responseHeaders.delete("content-length");
+            const responseBody = await upstream.arrayBuffer();
+
+            return new Response(responseBody, {
+                status: upstream.status,
+                statusText: upstream.statusText,
+                headers: responseHeaders,
+            });
+        }
+    );
+
+    return {
+        applied: true,
+        note: `local reverse proxy on ${proxy.origin} with ${halfDelayMs}ms pre-forward delay`,
+        stop: async () => {
+            controller.abort();
+            await listener.finished.catch(() => {});
+        },
+    };
+}
+
+async function main(): Promise<void> {
+    const config = buildConfig();
+    const resultPath = readOptionalResultPath();
+
+    await using workDir = await TempDir.create("livesync-cli-couchdb-bench");
+    const vaultA = workDir.join("vault-a");
+    const vaultB = workDir.join("vault-b");
+    const settingsA = workDir.join("settings-a.json");
+    const settingsB = workDir.join("settings-b.json");
+    await Deno.mkdir(vaultA, { recursive: true });
+    await Deno.mkdir(vaultB, { recursive: true });
+
+    await initSettingsFile(settingsA);
+    await initSettingsFile(settingsB);
+
+    await startCouchdb(config.couchdbBackendUri, config.couchdbUser, config.couchdbPassword, config.couchdbDbname);
+
+    const proxy = startCouchdbProxy({
+        backendUri: config.couchdbBackendUri,
+        proxyUri: config.couchdbProxyUri,
+        requestedRttMs: config.requestedRttMs,
+    });
+
+    try {
+        await Promise.all([
+            applyRemoteSyncSettings(settingsA, {
+                remoteType: "COUCHDB",
+                couchdbUri: config.couchdbProxyUri,
+                couchdbUser: config.couchdbUser,
+                couchdbPassword: config.couchdbPassword,
+                couchdbDbname: config.couchdbDbname,
+                encrypt: config.encrypt,
+                passphrase: config.passphrase,
+            }),
+            applyRemoteSyncSettings(settingsB, {
+                remoteType: "COUCHDB",
+                couchdbUri: config.couchdbProxyUri,
+                couchdbUser: config.couchdbUser,
+                couchdbPassword: config.couchdbPassword,
+                couchdbDbname: config.couchdbDbname,
+                encrypt: config.encrypt,
+                passphrase: config.passphrase,
+            }),
+        ]);
+
+        const seedFiles = await createDeterministicDataset({
+            rootDir: vaultA,
+            datasetDirName: config.datasetDirName,
+            seed: config.datasetSeed,
+            mdCount: config.mdFileCount,
+            mdMinSizeBytes: config.mdMinSizeBytes,
+            mdMaxSizeBytes: config.mdMaxSizeBytes,
+            binCount: config.binFileCount,
+            binSizeBytes: config.binSizeBytes,
+        });
+
+        const mirrorStart = nowMs();
+        await runCliOrFail(vaultA, "--settings", settingsA, "mirror");
+        const mirrorElapsed = nowMs() - mirrorStart;
+
+        const syncAStart = nowMs();
+        await runCliOrFail(vaultA, "--settings", settingsA, "sync");
+        const syncAElapsed = nowMs() - syncAStart;
+
+        const syncBStart = nowMs();
+        await runCliOrFail(vaultB, "--settings", settingsB, "sync");
+        const syncBElapsed = nowMs() - syncBStart;
+
+        const sampleFiles = pickSampleFiles(seedFiles.entries);
+        for (const sample of sampleFiles) {
+            const pulledPath = workDir.join(`pulled-${sample.relativePath.split("/").join("_")}`);
+            await runCliOrFail(vaultB, "--settings", settingsB, "pull", sample.relativePath, pulledPath);
+            await assertFilesEqual(
+                sample.absolutePath,
+                pulledPath,
+                `sample file mismatch after CouchDB sync: ${sample.relativePath}`
+            );
+        }
+
+        const result = {
+            mode: "couchdb-cli-benchmark",
+            couchdbBackendUri: config.couchdbBackendUri,
+            couchdbProxyUri: config.couchdbProxyUri,
+            couchdbDbname: config.couchdbDbname,
+            rttRequestedMs: config.requestedRttMs,
+            proxyApplied: proxy.applied,
+            proxyNote: proxy.note,
+            datasetSeed: config.datasetSeed,
+            datasetDirName: config.datasetDirName,
+            totalFiles: seedFiles.totalFiles,
+            totalBytes: seedFiles.totalBytes,
+            mdFileCount: seedFiles.mdCount,
+            binFileCount: seedFiles.binCount,
+            mirrorElapsedMs: Number(mirrorElapsed.toFixed(1)),
+            syncAElapsedMs: Number(syncAElapsed.toFixed(1)),
+            syncBElapsedMs: Number(syncBElapsed.toFixed(1)),
+            totalSyncElapsedMs: Number((syncAElapsed + syncBElapsed).toFixed(1)),
+            throughputBytesPerSec: Number((seedFiles.totalBytes / ((syncAElapsed + syncBElapsed) / 1000)).toFixed(2)),
+            throughputMiBPerSec: Number(
+                (seedFiles.totalBytes / ((syncAElapsed + syncBElapsed) / 1000) / 1024 / 1024).toFixed(4)
+            ),
+        };
+
+        if (resultPath) {
+            await Deno.writeTextFile(resultPath, JSON.stringify(result, null, 2));
+        }
+
+        console.log(JSON.stringify(result, null, 2));
+        console.error(
+            `[Benchmark] couchdb mirrored ${seedFiles.totalFiles} files (${formatBytes(seedFiles.totalBytes)}) in ${formatMs(
+                mirrorElapsed
+            )}, synced in ${formatMs(syncAElapsed + syncBElapsed)} (${result.throughputBytesPerSec} B/s, ${result.throughputMiBPerSec} MiB/s)`
+        );
+    } finally {
+        await proxy.stop();
+        await stopCouchdb().catch(() => {});
+    }
+}
+
+if (import.meta.main) {
+    main().catch((error) => {
+        console.error(`[Fatal Error]`, error);
+        Deno.exit(1);
+    });
+}

src/apps/cli/testdeno/bench-p2p.ts

@@ -0,0 +1,223 @@
+import { TempDir } from "./helpers/temp.ts";
+import { applyP2pSettings, applyP2pTestTweaks, initSettingsFile } from "./helpers/settings.ts";
+import { startCliInBackground } from "./helpers/backgroundCli.ts";
+import { discoverPeer, maybeStartLocalRelay, stopLocalRelayIfStarted } from "./helpers/p2p.ts";
+import { assertFilesEqual, runCliOrFail } from "./helpers/cli.ts";
+import { createDeterministicDataset, type DatasetEntry } from "./helpers/dataset.ts";
+
+type BenchmarkConfig = {
+    relay: string;
+    appId: string;
+    roomId: string;
+    passphrase: string;
+    datasetDirName: string;
+    datasetSeed: string;
+    mdFileCount: number;
+    mdMinSizeBytes: number;
+    mdMaxSizeBytes: number;
+    binFileCount: number;
+    binSizeBytes: number;
+    peersTimeoutSeconds: number;
+    syncTimeoutSeconds: number;
+};
+
+function readEnvString(name: string, fallback: string): string {
+    const value = Deno.env.get(name)?.trim();
+    return value && value.length > 0 ? value : fallback;
+}
+
+function readEnvNumber(name: string, fallback: number): number {
+    const raw = Deno.env.get(name);
+    if (raw === undefined || raw.trim() === "") {
+        return fallback;
+    }
+
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new Error(`${name} must be a positive number, got '${raw}'`);
+    }
+    return parsed;
+}
+
+function nowMs(): number {
+    return performance.now();
+}
+
+function formatMs(value: number): string {
+    return `${value.toFixed(1)} ms`;
+}
+
+function formatBytes(value: number): string {
+    if (value < 1024) {
+        return `${value} B`;
+    }
+    const kib = value / 1024;
+    if (kib < 1024) {
+        return `${kib.toFixed(1)} KiB`;
+    }
+    const mib = kib / 1024;
+    return `${mib.toFixed(1)} MiB`;
+}
+
+function buildConfig(): BenchmarkConfig {
+    return {
+        relay: readEnvString("BENCH_RELAY", "ws://localhost:4000/"),
+        appId: readEnvString("BENCH_APP_ID", "self-hosted-livesync-cli-benchmark"),
+        roomId: readEnvString("BENCH_ROOM_ID", `bench-room-${Date.now()}`),
+        passphrase: readEnvString("BENCH_PASSPHRASE", `bench-${Date.now()}`),
+        datasetDirName: readEnvString("BENCH_DATASET_DIR", "bench-dataset"),
+        datasetSeed: readEnvString("BENCH_SEED", "livesync-benchmark-seed"),
+        mdFileCount: Math.floor(readEnvNumber("BENCH_MD_FILE_COUNT", 1500)),
+        mdMinSizeBytes: Math.floor(readEnvNumber("BENCH_MD_MIN_SIZE_BYTES", 1024)),
+        mdMaxSizeBytes: Math.floor(readEnvNumber("BENCH_MD_MAX_SIZE_BYTES", 20 * 1024)),
+        binFileCount: Math.floor(readEnvNumber("BENCH_BIN_FILE_COUNT", 500)),
+        binSizeBytes: Math.floor(readEnvNumber("BENCH_BIN_SIZE_BYTES", 100 * 1024)),
+        peersTimeoutSeconds: readEnvNumber("BENCH_PEERS_TIMEOUT", 20),
+        syncTimeoutSeconds: readEnvNumber("BENCH_SYNC_TIMEOUT", 240),
+    };
+}
+
+function readOptionalResultPath(): string | undefined {
+    const raw = Deno.env.get("BENCH_RESULT_JSON")?.trim();
+    if (!raw) {
+        return undefined;
+    }
+    return raw;
+}
+
+function pickSampleFiles(entries: DatasetEntry[]): DatasetEntry[] {
+    if (entries.length === 0) {
+        return [];
+    }
+    const md = entries.find((e) => e.kind === "md");
+    const bin = entries.find((e) => e.kind === "bin");
+    const middle = entries[Math.floor(entries.length / 2)];
+    const last = entries[entries.length - 1];
+    const unique = new Map<string, DatasetEntry>();
+    for (const entry of [md, bin, middle, last]) {
+        if (entry) {
+            unique.set(entry.relativePath, entry);
+        }
+    }
+    return [...unique.values()];
+}
+
+async function main(): Promise<void> {
+    const config = buildConfig();
+    const resultPath = readOptionalResultPath();
+
+    const relayStarted = await maybeStartLocalRelay(config.relay);
+    await using workDir = await TempDir.create("livesync-cli-p2p-bench");
+
+    const hostVault = workDir.join("vault-host");
+    const clientVault = workDir.join("vault-client");
+    const hostSettings = workDir.join("settings-host.json");
+    const clientSettings = workDir.join("settings-client.json");
+
+    await Promise.all([
+        Deno.mkdir(hostVault, { recursive: true }),
+        Deno.mkdir(clientVault, { recursive: true }),
+        initSettingsFile(hostSettings),
+        initSettingsFile(clientSettings),
+    ]);
+
+    await Promise.all([
+        applyP2pSettings(hostSettings, config.roomId, config.passphrase, config.appId, config.relay, "~.*"),
+        applyP2pSettings(clientSettings, config.roomId, config.passphrase, config.appId, config.relay, "~.*"),
+    ]);
+
+    await Promise.all([
+        applyP2pTestTweaks(hostSettings, "p2p-bench-host", config.passphrase),
+        applyP2pTestTweaks(clientSettings, "p2p-bench-client", config.passphrase),
+    ]);
+
+    const seedFiles = await createDeterministicDataset({
+        rootDir: hostVault,
+        datasetDirName: config.datasetDirName,
+        seed: config.datasetSeed,
+        mdCount: config.mdFileCount,
+        mdMinSizeBytes: config.mdMinSizeBytes,
+        mdMaxSizeBytes: config.mdMaxSizeBytes,
+        binCount: config.binFileCount,
+        binSizeBytes: config.binSizeBytes,
+    });
+
+    const mirrorStart = nowMs();
+    await runCliOrFail(hostVault, "--settings", hostSettings, "mirror");
+    const mirrorElapsed = nowMs() - mirrorStart;
+
+    const host = startCliInBackground(hostVault, "--settings", hostSettings, "p2p-host");
+    try {
+        const hostReadyStart = nowMs();
+        await host.waitUntilContains("P2P host is running", 20000);
+        const hostReadyElapsed = nowMs() - hostReadyStart;
+
+        const peerDiscoveryStart = nowMs();
+        const peer = await discoverPeer(clientVault, clientSettings, config.peersTimeoutSeconds);
+        const peerDiscoveryElapsed = nowMs() - peerDiscoveryStart;
+
+        const syncStart = nowMs();
+        await runCliOrFail(
+            clientVault,
+            "--settings",
+            clientSettings,
+            "p2p-sync",
+            peer.id,
+            String(config.syncTimeoutSeconds)
+        );
+        const syncElapsed = nowMs() - syncStart;
+
+        const sampleFiles = pickSampleFiles(seedFiles.entries);
+        for (const sample of sampleFiles) {
+            const pulledPath = workDir.join(`pulled-${sample.relativePath.replaceAll("/", "_")}`);
+            await runCliOrFail(clientVault, "--settings", clientSettings, "pull", sample.relativePath, pulledPath);
+            await assertFilesEqual(
+                sample.absolutePath,
+                pulledPath,
+                `sample file mismatch after sync: ${sample.relativePath}`
+            );
+        }
+
+        const result = {
+            mode: "p2p-cli-benchmark",
+            relay: config.relay,
+            appId: config.appId,
+            roomId: config.roomId,
+            datasetSeed: config.datasetSeed,
+            datasetDirName: config.datasetDirName,
+            peerId: peer.id,
+            peerName: peer.name,
+            totalFiles: seedFiles.totalFiles,
+            totalBytes: seedFiles.totalBytes,
+            mdFileCount: seedFiles.mdCount,
+            binFileCount: seedFiles.binCount,
+            mirrorElapsedMs: Number(mirrorElapsed.toFixed(1)),
+            hostReadyElapsedMs: Number(hostReadyElapsed.toFixed(1)),
+            peerDiscoveryElapsedMs: Number(peerDiscoveryElapsed.toFixed(1)),
+            syncElapsedMs: Number(syncElapsed.toFixed(1)),
+            throughputBytesPerSec: Number((seedFiles.totalBytes / (syncElapsed / 1000)).toFixed(2)),
+            throughputMiBPerSec: Number((seedFiles.totalBytes / (syncElapsed / 1000) / 1024 / 1024).toFixed(4)),
+        };
+
+        if (resultPath) {
+            await Deno.writeTextFile(resultPath, JSON.stringify(result, null, 2));
+        }
+
+        console.log(JSON.stringify(result, null, 2));
+        console.error(
+            `[Benchmark] mirrored ${seedFiles.totalFiles} files (${formatBytes(seedFiles.totalBytes)}) in ${formatMs(mirrorElapsed)}, ` +
+                `synced in ${formatMs(syncElapsed)} ` +
+                `(${result.throughputBytesPerSec} B/s, ${result.throughputMiBPerSec} MiB/s)`
+        );
+    } finally {
+        await host.stop();
+        await stopLocalRelayIfStarted(relayStarted);
+    }
+}
+
+if (import.meta.main) {
+    main().catch((error) => {
+        console.error(`[Fatal Error]`, error);
+        Deno.exit(1);
+    });
+}

src/apps/cli/testdeno/bench-run-item1.sh

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+RESULTS_ROOT="${SCRIPT_DIR}/bench-results"
+TIMESTAMP="$(date +%Y%m%d-%H%M%S)"
+OUT_DIR="${RESULTS_ROOT}/${TIMESTAMP}"
+
+mkdir -p "${OUT_DIR}"
+
+echo "[bench-wrapper] output directory: ${OUT_DIR}"
+
+echo "[bench-wrapper] running p2p benchmark"
+(
+  cd "${SCRIPT_DIR}"
+  BENCH_RESULT_JSON="${OUT_DIR}/p2p.json" deno task bench:p2p
+)
+
+echo "[bench-wrapper] running couchdb benchmark with RTT ${BENCH_COUCHDB_RTT_MS:-default} ms (emulating HTTP network latency)"
+(
+  cd "${SCRIPT_DIR}"
+  BENCH_RESULT_JSON="${OUT_DIR}/couchdb.json" deno task bench:couchdb
+)
+
+cat > "${OUT_DIR}/README.txt" <<EOF
+Bench wrapper result set
+
+Generated at: ${TIMESTAMP}
+Directory: ${OUT_DIR}
+
+Files:
+- p2p.json
+- couchdb.json
+EOF
+
+echo "[bench-wrapper] verify outputs by cat"
+echo "========== ${OUT_DIR}/README.txt =========="
+cat "${OUT_DIR}/README.txt"
+echo "========== ${OUT_DIR}/p2p.json =========="
+cat "${OUT_DIR}/p2p.json"
+echo "========== ${OUT_DIR}/couchdb.json =========="
+cat "${OUT_DIR}/couchdb.json"
+
+echo "[bench-wrapper] done"
+echo "[bench-wrapper] result directory: ${OUT_DIR}"

src/apps/cli/testdeno/deno.json

@@ -12,8 +12,16 @@
         "test:p2p-sync": "deno test --env-file=.test.env -A --no-check test-p2p-sync.ts",
         "test:p2p-three-nodes": "deno test --env-file=.test.env -A --no-check test-p2p-three-nodes-conflict.ts",
         "test:p2p-upload-download": "deno test --env-file=.test.env -A --no-check test-p2p-upload-download-repro.ts",
+        "bench:p2p": "deno run --env-file=.test.env -A --no-check bench-p2p.ts",
+        "bench:couchdb": "deno run --env-file=.test.env -A --no-check bench-couchdb.ts",
+        "bench:item1": "bash ./bench-run-item1.sh",
+        "bench:item1:full": "BENCH_MD_FILE_COUNT=1500 BENCH_MD_MIN_SIZE_BYTES=1024 BENCH_MD_MAX_SIZE_BYTES=20480 BENCH_BIN_FILE_COUNT=500 BENCH_BIN_SIZE_BYTES=102400 BENCH_COUCHDB_RTT_MS=50 bash ./bench-run-item1.sh",
         "test:e2e-couchdb": "deno test --env-file=.test.env -A --no-check test-e2e-two-vaults-couchdb.ts",
-        "test:e2e-matrix": "deno test --env-file=.test.env -A --no-check test-e2e-two-vaults-matrix.ts"
+        "test:e2e-matrix": "deno test --env-file=.test.env -A --no-check test-e2e-two-vaults-matrix.ts",
+        "test:e2e-matrix:couchdb-enc0": "deno test --env-file=.test.env -A --no-check --filter='e2e matrix: COUCHDB-enc0' test-e2e-two-vaults-matrix.ts",
+        "test:e2e-matrix:couchdb-enc1": "deno test --env-file=.test.env -A --no-check --filter='e2e matrix: COUCHDB-enc1' test-e2e-two-vaults-matrix.ts",
+        "test:e2e-matrix:minio-enc0": "deno test --env-file=.test.env -A --no-check --filter='e2e matrix: MINIO-enc0' test-e2e-two-vaults-matrix.ts",
+        "test:e2e-matrix:minio-enc1": "deno test --env-file=.test.env -A --no-check --filter='e2e matrix: MINIO-enc1' test-e2e-two-vaults-matrix.ts"
     },
     "imports": {
         "@std/assert": "jsr:@std/assert@^1.0.13",

src/apps/cli/testdeno/helpers/cli.ts

@@ -39,27 +39,73 @@ function concatChunks(chunks: Uint8Array[]): Uint8Array {
     return out;
 }
 
+function formatTeeCommand(args: string[]): string {
+    return ["node", CLI_DIST, ...args].map((part) => JSON.stringify(part)).join(" ");
+}
+
+function createLineTeeWriter(
+    pid: number,
+    streamName: "stdout" | "stderr",
+    writer: (chunk: Uint8Array) => void
+): { write: (chunk: Uint8Array) => void; close: () => void } {
+    const enc = new TextEncoder();
+    const dec = new TextDecoder();
+    let pending = "";
+    let headerWritten = false;
+    const emitLine = (line: string) => {
+        if (!headerWritten) {
+            writer(enc.encode(`[CLI tee pid=${pid}:${streamName}]\n`));
+            headerWritten = true;
+        }
+        writer(enc.encode(`[CLI tee pid=${pid}:${streamName}] ${line}\n`));
+    };
+
+    const flush = (final = false) => {
+        let index = pending.indexOf("\n");
+        while (index >= 0) {
+            const line = pending.slice(0, index).replace(/\r$/, "");
+            pending = pending.slice(index + 1);
+            emitLine(line);
+            index = pending.indexOf("\n");
+        }
+        if (final && pending.length > 0) {
+            emitLine(pending.replace(/\r$/, ""));
+            pending = "";
+        }
+    };
+
+    return {
+        write(chunk: Uint8Array) {
+            pending += dec.decode(chunk, { stream: true });
+            flush(false);
+        },
+        close() {
+            pending += dec.decode();
+            flush(true);
+        },
+    };
+}
+
 async function collectStream(
     stream: ReadableStream<Uint8Array>,
-    teeTarget: WritableStream<Uint8Array> | null
+    teeTarget: { write: (chunk: Uint8Array) => void; close: () => void } | null
 ): Promise<Uint8Array> {
     const reader = stream.getReader();
     const chunks: Uint8Array[] = [];
-    const writer = teeTarget?.getWriter();
     try {
         while (true) {
             const { done, value } = await reader.read();
             if (done) break;
             if (value) {
                 chunks.push(value);
-                if (writer) {
-                    await writer.write(value);
+                if (teeTarget) {
+                    teeTarget.write(value);
                 }
             }
         }
     } finally {
-        if (writer) {
-            writer.releaseLock();
+        if (teeTarget) {
+            teeTarget.close();
         }
         reader.releaseLock();
     }
@@ -76,8 +122,20 @@ async function runNodeCommand(args: string[], stdinData?: Uint8Array): Promise<C
         stderr: "piped",
     }).spawn();
 
-    const stdoutPromise = collectStream(child.stdout, TEE_ENABLED ? Deno.stdout.writable : null);
-    const stderrPromise = collectStream(child.stderr, TEE_ENABLED ? Deno.stderr.writable : null);
+    if (TEE_ENABLED) {
+        Deno.stdout.writeSync(
+            new TextEncoder().encode(`[CLI tee pid=${child.pid}] process: ${formatTeeCommand(cliArgs)}\n`)
+        );
+    }
+
+    const stdoutPromise = collectStream(
+        child.stdout,
+        TEE_ENABLED ? createLineTeeWriter(child.pid, "stdout", (chunk) => Deno.stdout.writeSync(chunk)) : null
+    );
+    const stderrPromise = collectStream(
+        child.stderr,
+        TEE_ENABLED ? createLineTeeWriter(child.pid, "stderr", (chunk) => Deno.stderr.writeSync(chunk)) : null
+    );
 
     if (stdinData) {
         const w = child.stdin.getWriter();

src/apps/cli/testdeno/helpers/dataset.ts

@@ -0,0 +1,123 @@
+export type DeterministicDatasetConfig = {
+    rootDir: string;
+    datasetDirName: string;
+    seed: string;
+    mdCount: number;
+    mdMinSizeBytes: number;
+    mdMaxSizeBytes: number;
+    binCount: number;
+    binSizeBytes: number;
+};
+
+export type DatasetEntry = {
+    kind: "md" | "bin";
+    relativePath: string;
+    absolutePath: string;
+    size: number;
+};
+
+export type DeterministicDataset = {
+    rootDir: string;
+    datasetDirName: string;
+    seed: string;
+    entries: DatasetEntry[];
+    totalFiles: number;
+    totalBytes: number;
+    mdCount: number;
+    binCount: number;
+};
+
+function fnv1a32(input: string): number {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < input.length; i++) {
+        hash ^= input.charCodeAt(i) & 0xff;
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return hash >>> 0;
+}
+
+function createXorshift32(seed: number): () => number {
+    let state = seed >>> 0;
+    if (state === 0) {
+        state = 0x9e3779b9;
+    }
+    return () => {
+        state ^= state << 13;
+        state ^= state >>> 17;
+        state ^= state << 5;
+        return state >>> 0;
+    };
+}
+
+function createTextBytes(size: number, fileIndex: number, seed: string): Uint8Array {
+    const template =
+        `# Bench file ${fileIndex}\n` +
+        `seed: ${seed}\n` +
+        "lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.\n";
+
+    const templateBytes = new TextEncoder().encode(template);
+    const out = new Uint8Array(size);
+    for (let i = 0; i < size; i++) {
+        out[i] = templateBytes[i % templateBytes.length];
+    }
+    return out;
+}
+
+function toPath(rootDir: string, relativePath: string): string {
+    return `${rootDir}/${relativePath}`;
+}
+
+export async function createDeterministicDataset(config: DeterministicDatasetConfig): Promise<DeterministicDataset> {
+    if (config.mdCount < 0 || config.binCount < 0) {
+        throw new Error("mdCount and binCount must be non-negative");
+    }
+    if (config.mdMinSizeBytes <= 0 || config.mdMaxSizeBytes <= 0 || config.binSizeBytes <= 0) {
+        throw new Error("all size values must be positive");
+    }
+    if (config.mdMinSizeBytes > config.mdMaxSizeBytes) {
+        throw new Error("mdMinSizeBytes must be <= mdMaxSizeBytes");
+    }
+
+    const datasetRoot = toPath(config.rootDir, config.datasetDirName);
+    const mdDir = `${datasetRoot}/md`;
+    const binDir = `${datasetRoot}/bin`;
+    await Deno.mkdir(mdDir, { recursive: true });
+    await Deno.mkdir(binDir, { recursive: true });
+
+    const nextRandom = createXorshift32(fnv1a32(config.seed));
+    const mdRange = config.mdMaxSizeBytes - config.mdMinSizeBytes + 1;
+    const entries: DatasetEntry[] = [];
+
+    for (let index = 0; index < config.mdCount; index++) {
+        const size = config.mdMinSizeBytes + (nextRandom() % mdRange);
+        const relativePath = `${config.datasetDirName}/md/file-${String(index).padStart(4, "0")}.md`;
+        const absolutePath = toPath(config.rootDir, relativePath);
+        const body = createTextBytes(size, index, config.seed);
+        await Deno.writeFile(absolutePath, body);
+        entries.push({ kind: "md", relativePath, absolutePath, size });
+    }
+
+    for (let index = 0; index < config.binCount; index++) {
+        const size = config.binSizeBytes;
+        const relativePath = `${config.datasetDirName}/bin/file-${String(index).padStart(4, "0")}.bin`;
+        const absolutePath = toPath(config.rootDir, relativePath);
+        const body = new Uint8Array(size);
+        for (let i = 0; i < size; i++) {
+            body[i] = nextRandom() & 0xff;
+        }
+        await Deno.writeFile(absolutePath, body);
+        entries.push({ kind: "bin", relativePath, absolutePath, size });
+    }
+
+    const totalBytes = entries.reduce((sum, e) => sum + e.size, 0);
+    return {
+        rootDir: config.rootDir,
+        datasetDirName: config.datasetDirName,
+        seed: config.seed,
+        entries,
+        totalFiles: entries.length,
+        totalBytes,
+        mdCount: config.mdCount,
+        binCount: config.binCount,
+    };
+}

src/apps/cli/testdeno/helpers/docker.ts

@@ -14,6 +14,11 @@ type DockerInvoker = {
 
 let dockerInvokerPromise: Promise<DockerInvoker> | null = null;
 const DOCKER_TEE = Deno.env.get("LIVESYNC_DOCKER_TEE") === "1" || Deno.env.get("LIVESYNC_TEST_TEE") === "1";
+const trackedContainers = new Set<string>();
+const CLEANUP_SIGNALS: Deno.Signal[] = ["SIGINT", "SIGTERM"];
+let signalCleanupHandlersInstalled = false;
+let signalCleanupInProgress = false;
+const signalCleanupHandlers = new Map<Deno.Signal, () => void>();
 
 // ---------------------------------------------------------------------------
 // Low-level docker wrapper
@@ -27,29 +32,53 @@ function parseCommand(command: string): { bin: string; prefix: string[] } {
     return { bin: parts[0], prefix: parts.slice(1) };
 }
 
-async function runCommand(bin: string, args: string[]): Promise<{ code: number; stdout: string; stderr: string }> {
-    const cmd = new Deno.Command(bin, {
-        args,
-        stdin: "null",
-        stdout: "piped",
-        stderr: "piped",
-    });
+async function collectStream(
+    stream: ReadableStream<Uint8Array>,
+    teeTarget: ((chunk: Uint8Array) => void) | null
+): Promise<Uint8Array> {
+    const reader = stream.getReader();
+    const chunks: Uint8Array[] = [];
     try {
-        const { code, stdout, stderr } = await cmd.output();
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            if (!value) continue;
+            chunks.push(value);
+            if (teeTarget) {
+                teeTarget(value);
+            }
+        }
+    } finally {
+        reader.releaseLock();
+    }
+
+    const total = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        out.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return out;
+}
+
+async function runCommand(bin: string, args: string[]): Promise<{ code: number; stdout: string; stderr: string }> {
+    try {
+        const child = new Deno.Command(bin, {
+            args,
+            stdin: "null",
+            stdout: "piped",
+            stderr: "piped",
+        }).spawn();
+        const stdoutPromise = collectStream(child.stdout, DOCKER_TEE ? (chunk) => Deno.stdout.writeSync(chunk) : null);
+        const stderrPromise = collectStream(child.stderr, DOCKER_TEE ? (chunk) => Deno.stderr.writeSync(chunk) : null);
+        const [status, stdout, stderr] = await Promise.all([child.status, stdoutPromise, stderrPromise]);
         const dec = new TextDecoder();
         const result = {
-            code,
+            code: status.code,
             stdout: dec.decode(stdout),
             stderr: dec.decode(stderr),
         };
-        if (DOCKER_TEE) {
-            if (result.stdout.trim().length > 0) {
-                console.log(`[docker:${bin}] ${result.stdout.trimEnd()}`);
-            }
-            if (result.stderr.trim().length > 0) {
-                console.error(`[docker:${bin}] ${result.stderr.trimEnd()}`);
-            }
-        }
         return result;
     } catch (err) {
         if (err instanceof Deno.errors.NotFound) {
@@ -159,6 +188,73 @@ async function dockerOrFail(...args: string[]): Promise<string> {
     return r.stdout;
 }
 
+async function stopAndRemoveContainer(container: string): Promise<void> {
+    await docker("stop", container).catch(() => {});
+    await docker("rm", container).catch(() => {});
+}
+
+async function cleanupTrackedContainers(reason: string): Promise<void> {
+    const names = [...trackedContainers];
+    if (names.length === 0) return;
+
+    console.warn(`[WARN] cleaning up tracked containers on ${reason}: ${names.join(", ")}`);
+    for (const container of names.reverse()) {
+        await stopAndRemoveContainer(container);
+        trackedContainers.delete(container);
+    }
+}
+
+async function handleSignalCleanup(signal: Deno.Signal): Promise<void> {
+    if (signalCleanupInProgress) return;
+    signalCleanupInProgress = true;
+    try {
+        await cleanupTrackedContainers(`signal ${signal}`);
+    } finally {
+        Deno.exit(signal === "SIGINT" ? 130 : 143);
+    }
+}
+
+function ensureSignalCleanupHandlers(): void {
+    if (signalCleanupHandlersInstalled) return;
+    signalCleanupHandlersInstalled = true;
+    for (const signal of CLEANUP_SIGNALS) {
+        const listener = () => {
+            void handleSignalCleanup(signal);
+        };
+        try {
+            Deno.addSignalListener(signal, listener);
+            signalCleanupHandlers.set(signal, listener);
+        } catch {
+            // Unsupported signal on this platform.
+        }
+    }
+}
+
+function removeSignalCleanupHandlers(): void {
+    if (!signalCleanupHandlersInstalled) return;
+    for (const [signal, listener] of signalCleanupHandlers) {
+        try {
+            Deno.removeSignalListener(signal, listener);
+        } catch {
+            // Ignore if already removed or unsupported.
+        }
+    }
+    signalCleanupHandlers.clear();
+    signalCleanupHandlersInstalled = false;
+}
+
+function trackContainer(container: string): void {
+    ensureSignalCleanupHandlers();
+    trackedContainers.add(container);
+}
+
+function untrackContainer(container: string): void {
+    trackedContainers.delete(container);
+    if (trackedContainers.size === 0) {
+        removeSignalCleanupHandlers();
+    }
+}
+
 function sleep(ms: number): Promise<void> {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -235,8 +331,8 @@ const MINIO_IMAGE = "minio/minio";
 const MINIO_MC_IMAGE = "minio/mc";
 
 export async function stopCouchdb(): Promise<void> {
-    await docker("stop", COUCHDB_CONTAINER);
-    await docker("rm", COUCHDB_CONTAINER);
+    await stopAndRemoveContainer(COUCHDB_CONTAINER);
+    untrackContainer(COUCHDB_CONTAINER);
 }
 
 /**
@@ -265,6 +361,7 @@ export async function startCouchdb(couchdbUri: string, user: string, password: s
         "COUCHDB_SINGLE_NODE=y",
         COUCHDB_IMAGE
     );
+    trackContainer(COUCHDB_CONTAINER);
 
     console.log("[INFO] initialising CouchDB");
     await initCouchdb(couchdbUri, user, password);
@@ -365,8 +462,8 @@ function shQuote(value: string): string {
 }
 
 export async function stopMinio(): Promise<void> {
-    await docker("stop", MINIO_CONTAINER);
-    await docker("rm", MINIO_CONTAINER);
+    await stopAndRemoveContainer(MINIO_CONTAINER);
+    untrackContainer(MINIO_CONTAINER);
 }
 
 async function initMinioBucket(
@@ -446,6 +543,7 @@ export async function startMinio(
         "--console-address",
         ":9001"
     );
+    trackContainer(MINIO_CONTAINER);
 
     console.log(`[INFO] initialising MinIO test bucket: ${bucket}`);
     let initialised = false;
@@ -493,8 +591,8 @@ EOF
 exec /app/strfry --config /tmp/strfry.conf relay`;
 
 export async function stopP2pRelay(): Promise<void> {
-    await docker("stop", P2P_RELAY_CONTAINER);
-    await docker("rm", P2P_RELAY_CONTAINER);
+    await stopAndRemoveContainer(P2P_RELAY_CONTAINER);
+    untrackContainer(P2P_RELAY_CONTAINER);
 }
 
 /**
@@ -523,6 +621,7 @@ export async function startP2pRelay(): Promise<void> {
         "-lc",
         STRFRY_BOOTSTRAP_SH
     );
+    trackContainer(P2P_RELAY_CONTAINER);
 }
 
 export function isLocalP2pRelay(relayUrl: string): boolean {

src/apps/cli/testdeno/helpers/net.ts

@@ -0,0 +1,49 @@
+type WaitForPortOptions = {
+    timeoutMs?: number;
+    intervalMs?: number;
+    connectTimeoutMs?: number;
+};
+
+function sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function connectWithTimeout(hostname: string, port: number, timeoutMs: number): Promise<void> {
+    let timer: number | undefined;
+    try {
+        const connPromise = Deno.connect({ hostname, port });
+        const timeoutPromise = new Promise<never>((_, reject) => {
+            timer = setTimeout(() => reject(new Error(`connect timeout after ${timeoutMs}ms`)), timeoutMs);
+        });
+        const conn = await Promise.race([connPromise, timeoutPromise]);
+        conn.close();
+    } finally {
+        if (timer !== undefined) {
+            clearTimeout(timer);
+        }
+    }
+}
+
+export async function waitForPort(hostname: string, port: number, options: WaitForPortOptions = {}): Promise<void> {
+    const timeoutMs = options.timeoutMs ?? 15000;
+    const intervalMs = options.intervalMs ?? 250;
+    const connectTimeoutMs = options.connectTimeoutMs ?? 1000;
+
+    const started = Date.now();
+    let lastError: unknown;
+
+    while (Date.now() - started < timeoutMs) {
+        try {
+            await connectWithTimeout(hostname, port, connectTimeoutMs);
+            return;
+        } catch (error) {
+            lastError = error;
+            await sleep(intervalMs);
+        }
+    }
+
+    throw new Error(
+        `Port ${hostname}:${port} did not become ready within ${timeoutMs}ms` +
+            (lastError ? ` (last error: ${String(lastError)})` : "")
+    );
+}

src/apps/cli/testdeno/helpers/p2p.ts

@@ -1,11 +1,26 @@
 import { runCli } from "./cli.ts";
 import { isLocalP2pRelay, startP2pRelay, stopP2pRelay } from "./docker.ts";
+import { waitForPort } from "./net.ts";
 
 export type PeerEntry = {
     id: string;
     name: string;
 };
 
+function sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function parseRelayEndpoint(relay: string): { hostname: string; port: number } {
+    const url = new URL(relay);
+    const port = url.port ? Number(url.port) : url.protocol === "ws:" ? 80 : url.protocol === "wss:" ? 443 : NaN;
+    if (!Number.isFinite(port)) {
+        throw new Error(`Unsupported relay URL: ${relay}`);
+    }
+    const hostname = url.hostname === "localhost" ? "127.0.0.1" : url.hostname;
+    return { hostname, port };
+}
+
 export function parsePeerLines(output: string): PeerEntry[] {
     return output
         .split(/\r?\n/)
@@ -20,28 +35,55 @@ export async function discoverPeer(
     timeoutSeconds: number,
     targetPeer?: string
 ): Promise<PeerEntry> {
-    const result = await runCli(vaultDir, "--settings", settingsFile, "p2p-peers", String(timeoutSeconds));
-    if (result.code !== 0) {
-        throw new Error(`p2p-peers failed\n${result.combined}`);
-    }
-    const peers = parsePeerLines(result.stdout);
-    if (targetPeer) {
-        const matched = peers.find((peer) => peer.id === targetPeer || peer.name === targetPeer);
-        if (matched) return matched;
-    }
-    if (peers.length === 0) {
-        const fallback = result.combined.match(/Advertisement from\s+([^\s]+)/);
-        if (fallback?.[1]) {
-            return { id: fallback[1], name: fallback[1] };
+    const retries = Math.max(0, Number(Deno.env.get("LIVESYNC_P2P_PEERS_RETRY") ?? "3"));
+    let lastCombined = "";
+
+    for (let attempt = 0; attempt <= retries; attempt++) {
+        const result = await runCli(vaultDir, "--settings", settingsFile, "p2p-peers", String(timeoutSeconds));
+        lastCombined = result.combined;
+
+        if (result.code === 0) {
+            const peers = parsePeerLines(result.stdout);
+            if (targetPeer) {
+                const matched = peers.find((peer) => peer.id === targetPeer || peer.name === targetPeer);
+                if (matched) return matched;
+            }
+            if (peers.length > 0) {
+                return peers[0];
+            }
+
+            const fallback = result.combined.match(/Advertisement from\s+([^\s]+)/);
+            if (fallback?.[1]) {
+                return { id: fallback[1], name: fallback[1] };
+            }
         }
-        throw new Error(`No peers discovered\n${result.combined}`);
+
+        if (attempt < retries) {
+            const waitMs = 400 * (attempt + 1);
+            console.warn(
+                `[WARN] p2p-peers returned no usable peers, retrying (${attempt + 1}/${retries}) in ${waitMs}ms`
+            );
+            await sleep(waitMs);
+            continue;
+        }
+
+        throw new Error(
+            result.code !== 0 ? `p2p-peers failed\n${result.combined}` : `No peers discovered\n${result.combined}`
+        );
     }
-    return peers[0];
+
+    throw new Error(`No peers discovered\n${lastCombined}`);
 }
 
 export async function maybeStartLocalRelay(relay: string): Promise<boolean> {
     if (!isLocalP2pRelay(relay)) return false;
     await startP2pRelay();
+    const endpoint = parseRelayEndpoint(relay);
+    await waitForPort(endpoint.hostname, endpoint.port, {
+        timeoutMs: Number(Deno.env.get("LIVESYNC_P2P_RELAY_READY_TIMEOUT_MS") ?? "15000"),
+        intervalMs: Number(Deno.env.get("LIVESYNC_P2P_RELAY_READY_INTERVAL_MS") ?? "250"),
+        connectTimeoutMs: Number(Deno.env.get("LIVESYNC_P2P_RELAY_CONNECT_TIMEOUT_MS") ?? "1000"),
+    });
     return true;
 }
 

src/apps/cli/testdeno/test-p2p-peers-local-relay.ts

@@ -9,6 +9,9 @@ Deno.test("p2p-peers: discovers host through local relay", async () => {
     const roomId = Deno.env.get("ROOM_ID") ?? `room-${Date.now()}`;
     const passphrase = Deno.env.get("PASSPHRASE") ?? "test";
     const timeoutSeconds = Number(Deno.env.get("TIMEOUT_SECONDS") ?? "8");
+    const nonce = `${Date.now()}-${crypto.randomUUID().slice(0, 8)}`;
+    const hostPeerName = Deno.env.get("HOST_PEER_NAME") ?? `p2p-host-${nonce}`;
+    const clientPeerName = Deno.env.get("CLIENT_PEER_NAME") ?? `p2p-client-${nonce}`;
 
     await using workDir = await TempDir.create("livesync-cli-p2p-peers-local-relay");
     const hostVault = workDir.join("vault-host");
@@ -24,15 +27,16 @@ Deno.test("p2p-peers: discovers host through local relay", async () => {
         await initSettingsFile(clientSettings);
         await applyP2pSettings(hostSettings, roomId, passphrase, "self-hosted-livesync-cli-tests", relay);
         await applyP2pSettings(clientSettings, roomId, passphrase, "self-hosted-livesync-cli-tests", relay);
-        await applyP2pTestTweaks(hostSettings, "p2p-host", passphrase);
-        await applyP2pTestTweaks(clientSettings, "p2p-client", passphrase);
+        await applyP2pTestTweaks(hostSettings, hostPeerName, passphrase);
+        await applyP2pTestTweaks(clientSettings, clientPeerName, passphrase);
 
         const host = startCliInBackground(hostVault, "--settings", hostSettings, "p2p-host");
         try {
             await host.waitUntilContains("P2P host is running", 20000);
-            const peer = await discoverPeer(clientVault, clientSettings, timeoutSeconds);
+            const peer = await discoverPeer(clientVault, clientSettings, timeoutSeconds, hostPeerName);
             assert(peer.id.length > 0);
             assert(peer.name.length > 0);
+            assert(peer.name === hostPeerName, `expected peer '${hostPeerName}', got '${peer.name}'`);
         } finally {
             await host.stop();
         }

src/apps/cli/testdeno/test-p2p-sync.ts

@@ -11,6 +11,9 @@ Deno.test("p2p-sync: discovers peer and completes sync", async () => {
     const passphrase = Deno.env.get("PASSPHRASE") ?? "test";
     const peersTimeout = Number(Deno.env.get("PEERS_TIMEOUT") ?? "12");
     const syncTimeout = Number(Deno.env.get("SYNC_TIMEOUT") ?? "15");
+    const nonce = `${Date.now()}-${crypto.randomUUID().slice(0, 8)}`;
+    const hostPeerName = Deno.env.get("HOST_PEER_NAME") ?? `p2p-host-${nonce}`;
+    const clientPeerName = Deno.env.get("CLIENT_PEER_NAME") ?? `p2p-client-${nonce}`;
 
     await using workDir = await TempDir.create("livesync-cli-p2p-sync");
     const hostVault = workDir.join("vault-host");
@@ -26,8 +29,8 @@ Deno.test("p2p-sync: discovers peer and completes sync", async () => {
         await initSettingsFile(clientSettings);
         await applyP2pSettings(hostSettings, roomId, passphrase, "self-hosted-livesync-cli-tests", relay);
         await applyP2pSettings(clientSettings, roomId, passphrase, "self-hosted-livesync-cli-tests", relay);
-        await applyP2pTestTweaks(hostSettings, "p2p-host", passphrase);
-        await applyP2pTestTweaks(clientSettings, "p2p-client", passphrase);
+        await applyP2pTestTweaks(hostSettings, hostPeerName, passphrase);
+        await applyP2pTestTweaks(clientSettings, clientPeerName, passphrase);
 
         const host = startCliInBackground(hostVault, "--settings", hostSettings, "p2p-host");
         try {
@@ -36,7 +39,7 @@ Deno.test("p2p-sync: discovers peer and completes sync", async () => {
                 clientVault,
                 clientSettings,
                 peersTimeout,
-                Deno.env.get("TARGET_PEER") ?? undefined
+                Deno.env.get("TARGET_PEER") ?? hostPeerName
             );
             const syncResult = await runCli(
                 clientVault,

src/apps/cli/testdeno/test-p2p-three-nodes-conflict.ts

@@ -1,6 +1,6 @@
 import { assert } from "@std/assert";
 import { TempDir } from "./helpers/temp.ts";
-import { applyP2pSettings, initSettingsFile } from "./helpers/settings.ts";
+import { applyP2pSettings, applyP2pTestTweaks, initSettingsFile } from "./helpers/settings.ts";
 import { startCliInBackground } from "./helpers/backgroundCli.ts";
 import { discoverPeer, maybeStartLocalRelay, stopLocalRelayIfStarted } from "./helpers/p2p.ts";
 import { jsonStringField, runCliOrFail, runCliWithInputOrFail, sanitiseCatStdout } from "./helpers/cli.ts";
@@ -12,6 +12,10 @@ Deno.test("p2p: three nodes detect and resolve conflicts", async () => {
     const appId = Deno.env.get("APP_ID") ?? "self-hosted-livesync-cli-tests";
     const peersTimeout = Number(Deno.env.get("PEERS_TIMEOUT") ?? "10");
     const syncTimeout = Number(Deno.env.get("SYNC_TIMEOUT") ?? "15");
+    const nonce = `${Date.now()}-${crypto.randomUUID().slice(0, 8)}`;
+    const hostPeerName = Deno.env.get("HOST_PEER_NAME") ?? `p2p-host-${nonce}`;
+    const peerNameB = Deno.env.get("PEER_NAME_B") ?? `p2p-client-b-${nonce}`;
+    const peerNameC = Deno.env.get("PEER_NAME_C") ?? `p2p-client-c-${nonce}`;
 
     await using workDir = await TempDir.create("livesync-cli-p2p-3nodes");
     const vaultA = workDir.join("vault-a");
@@ -26,16 +30,21 @@ Deno.test("p2p: three nodes detect and resolve conflicts", async () => {
 
     const relayStarted = await maybeStartLocalRelay(relay);
     try {
-        for (const settings of [settingsA, settingsB, settingsC]) {
-            await initSettingsFile(settings);
-            await applyP2pSettings(settings, roomId, passphrase, appId, relay);
-        }
+        await initSettingsFile(settingsA);
+        await initSettingsFile(settingsB);
+        await initSettingsFile(settingsC);
+        await applyP2pSettings(settingsA, roomId, passphrase, appId, relay);
+        await applyP2pSettings(settingsB, roomId, passphrase, appId, relay);
+        await applyP2pSettings(settingsC, roomId, passphrase, appId, relay);
+        await applyP2pTestTweaks(settingsA, hostPeerName, passphrase);
+        await applyP2pTestTweaks(settingsB, peerNameB, passphrase);
+        await applyP2pTestTweaks(settingsC, peerNameC, passphrase);
 
         const host = startCliInBackground(vaultA, "--settings", settingsA, "p2p-host");
         try {
             await host.waitUntilContains("P2P host is running", 20000);
-            const peerFromB = await discoverPeer(vaultB, settingsB, peersTimeout);
-            const peerFromC = await discoverPeer(vaultC, settingsC, peersTimeout);
+            const peerFromB = await discoverPeer(vaultB, settingsB, peersTimeout, hostPeerName);
+            const peerFromC = await discoverPeer(vaultC, settingsC, peersTimeout, hostPeerName);
             const targetPath = "p2p/conflicted-from-two-clients.txt";
 
             await runCliWithInputOrFail("from-client-b-v1\n", vaultB, "--settings", settingsB, "put", targetPath);

src/features/ConfigSync/CmdConfigSync.ts

@@ -68,7 +68,7 @@ import { ConflictResolveModal } from "../../modules/features/InteractiveConflict
 import { Semaphore } from "octagonal-wheels/concurrency/semaphore";
 import { EVENT_REQUEST_OPEN_PLUGIN_SYNC_DIALOG, eventHub } from "../../common/events.ts";
 import { PluginDialogModal } from "./PluginDialogModal.ts";
-import { $msg } from "@/lib/src/common/i18n.ts";
+import { $msg } from "src/lib/src/common/i18n.ts";
 import type { InjectableServiceHub } from "../../lib/src/services/InjectableServices.ts";
 import type { LiveSyncCore } from "../../main.ts";
 

src/features/P2PSync/P2PReplicator/P2PServerStatusCard.svelte

@@ -24,7 +24,6 @@
     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());
@@ -49,18 +48,6 @@
         }
     }
 
-    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;
@@ -71,7 +58,6 @@
         });
         const unsubscribeSettings = eventHub.onEvent(EVENT_SETTING_SAVED, (settings) => {
             roomSuffix = extractP2PRoomSuffix(settings?.P2P_roomID ?? "");
-            useDiagRTC = settings?.P2P_useDiagRTC ?? false;
         });
 
         fireAndForget(async () => {
@@ -145,48 +131,6 @@
         </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>
@@ -246,11 +190,6 @@
         margin-top: 0.25rem;
     }
 
-    .diag-toggle-row {
-        align-items: center;
-        margin-top: 0.25rem;
-    }
-
     .broadcast-label {
         font-size: 0.9rem;
         color: var(--text-normal);
@@ -282,29 +221,4 @@
         background-color: var(--interactive-hover);
         color: var(--text-normal);
     }
-
-    .diag-section {
-        border-top: 1px solid var(--divider-color);
-        margin-top: 0.75rem;
-        padding-top: 0.75rem;
-    }
-
-    .diag-section h4 {
-        margin: 0 0 0.5rem 0;
-        font-size: 0.9rem;
-        font-weight: 600;
-    }
-
-    .diag-grid {
-        display: grid;
-        grid-template-columns: repeat(auto-fit, minmax(130px, 1fr));
-        gap: 0.35rem 0.75rem;
-    }
-
-    .diag-item {
-        display: flex;
-        justify-content: space-between;
-        font-size: 0.85rem;
-        gap: 0.5rem;
-    }
 </style>

src/main.ts

@@ -12,6 +12,8 @@ import { ModuleObsidianEvents } from "./modules/essentialObsidian/ModuleObsidian
 import { ModuleObsidianSettingDialogue } from "./modules/features/ModuleObsidianSettingTab.ts";
 import { ModuleObsidianDocumentHistory } from "./modules/features/ModuleObsidianDocumentHistory.ts";
 import { ModuleObsidianGlobalHistory } from "./modules/features/ModuleGlobalHistory.ts";
+import { ModuleIntegratedTest } from "./modules/extras/ModuleIntegratedTest.ts";
+import { ModuleReplicateTest } from "./modules/extras/ModuleReplicateTest.ts";
 import { LocalDatabaseMaintenance } from "./features/LocalDatabaseMainte/CmdLocalDatabaseMainte.ts";
 import type { InjectableServiceHub } from "@lib/services/implements/injectable/InjectableServiceHub.ts";
 import { ObsidianServiceHub } from "./modules/services/ObsidianServiceHub.ts";
@@ -154,6 +156,8 @@ export default class ObsidianLiveSyncPlugin extends Plugin {
                     new ModuleInteractiveConflictResolver(this, core),
                     new ModuleObsidianGlobalHistory(this, core),
                     new ModuleDev(this, core),
+                    new ModuleReplicateTest(this, core),
+                    new ModuleIntegratedTest(this, core),
                     new SetupManager(core), // this should be moved to core?
                     new ModuleMigration(core),
                 ];

src/modules/extras/ModuleIntegratedTest.ts

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

src/modules/extras/ModuleReplicateTest.ts

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

src/modules/features/DocumentHistory/DocumentHistoryModal.ts

@@ -56,7 +56,6 @@ export class DocumentHistoryModal extends Modal {
     info!: HTMLDivElement;
     fileInfo!: HTMLDivElement;
     showDiff = false;
-    diffOnly = false;
     id?: DocumentID;
 
     file: FilePathWithPrefix;
@@ -71,15 +70,6 @@ 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,
@@ -98,12 +88,9 @@ export class DocumentHistoryModal extends Modal {
         if (!file && id) {
             this.file = this.services.path.id2path(id);
         }
-        if (this.app.loadLocalStorage("ols-history-highlightdiff") == "1") {
+        if (localStorage.getItem("ols-history-highlightdiff") == "1") {
             this.showDiff = true;
         }
-        if (this.app.loadLocalStorage("ols-history-diffonly") == "1") {
-            this.diffOnly = true;
-        }
     }
 
     async loadFile(initialRev?: string) {
@@ -164,48 +151,17 @@ export class DocumentHistoryModal extends Modal {
     }
 
     appendTextDiff(diff: [number, string][]) {
-        let hasOmitted = false;
         for (const [operation, text] of diff) {
             if (operation == DIFF_DELETE) {
-                this.appendSearchHighlightedText(this.contentView.createSpan({ cls: "history-deleted" }), text);
-                hasOmitted = false;
+                this.contentView.createSpan({ text, cls: "history-deleted" });
             } else if (operation == DIFF_EQUAL) {
-                if (this.diffOnly) {
-                    if (!hasOmitted) {
-                        this.contentView.appendText("\n...\n");
-                        hasOmitted = true;
-                    }
-                } else {
-                    this.appendSearchHighlightedText(this.contentView.createSpan({ cls: "history-normal" }), text);
-                }
+                this.contentView.createSpan({ text, cls: "history-normal" });
             } else if (operation == DIFF_INSERT) {
-                this.appendSearchHighlightedText(this.contentView.createSpan({ cls: "history-added" }), text);
-                hasOmitted = false;
+                this.contentView.createSpan({ text, cls: "history-added" });
             }
         }
     }
 
-    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" });
@@ -302,7 +258,7 @@ export class DocumentHistoryModal extends Modal {
                     if (this.currentDeleted) {
                         this.appendDeletedNotice();
                     }
-                    this.appendSearchHighlightedText(this.contentView, w1data);
+                    this.contentView.appendText(w1data);
                 }
             }
         }
@@ -310,11 +266,6 @@ 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" });
-            }
         }
     }
 
@@ -342,7 +293,7 @@ export class DocumentHistoryModal extends Modal {
         target.classList.add("diff-focused");
         target.scrollIntoView({ behavior: "smooth", block: "center" });
 
-        this.diffNavIndicator.setText(`${this.currentDiffIndex + 1}/${diffElements.length}`);
+        this.diffNavIndicator.textContent = `${this.currentDiffIndex + 1}/${diffElements.length}`;
     }
 
     /**
@@ -353,9 +304,9 @@ export class DocumentHistoryModal extends Modal {
         if (this.diffNavIndicator) {
             if (this.showDiff) {
                 const diffElements = this.contentView.querySelectorAll(".history-added, .history-deleted");
-                this.diffNavIndicator.setText(diffElements.length > 0 ? `0/${diffElements.length}` : "\u2014");
+                this.diffNavIndicator.textContent = diffElements.length > 0 ? `0/${diffElements.length}` : "\u2014";
             } else {
-                this.diffNavIndicator.setText("\u2014");
+                this.diffNavIndicator.textContent = "\u2014";
             }
         }
         this.updateDiffNavVisibility();
@@ -368,117 +319,6 @@ 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() {
@@ -487,42 +327,6 @@ 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");
 
@@ -538,43 +342,24 @@ export class DocumentHistoryModal extends Modal {
         const diffOptionsRow = contentEl.createDiv("");
         diffOptionsRow.addClass("op-info");
         diffOptionsRow.addClass("diff-options-row");
-        diffOptionsRow.addClass("history-diff-options-row");
 
-        const highlightDiffContainer = diffOptionsRow.createDiv("");
-        highlightDiffContainer.addClass("history-highlight-diff-container");
-
-        highlightDiffContainer.createEl("label", {}, (label) => {
-            label.addClass("history-highlight-diff-label");
-            label.createEl("input", { type: "checkbox" }, (checkbox) => {
-                if (this.showDiff) {
-                    checkbox.checked = true;
-                }
-                checkbox.addEventListener("input", (evt: any) => {
-                    this.showDiff = checkbox.checked;
-                    this.app.saveLocalStorage("ols-history-highlightdiff", this.showDiff == true ? "1" : null);
-                    this.updateDiffNavVisibility();
-                    void scheduleOnceIfDuplicated("loadRevs", () => this.loadRevs());
-                });
-            });
+        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());
+                    });
+                })
+            );
             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");

src/modules/features/InteractiveConflictResolving/ConflictResolveModal.ts

@@ -27,9 +27,6 @@ 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);
@@ -50,7 +47,7 @@ export class ConflictResolveModal extends Modal {
         const lines = text.split("\n");
         lines.forEach((line, index) => {
             const span = container.createSpan({ cls });
-            span.setText(line);
+            span.textContent = line;
             if (index < lines.length - 1) {
                 container.createSpan({ cls: "ls-mark-cr" });
                 container.createEl("br");
@@ -65,33 +62,6 @@ 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
@@ -108,26 +78,10 @@ export class ConflictResolveModal extends Modal {
         // sendValue("close-resolve-conflict:" + this.filename, false);
         this.titleEl.setText(this.title);
         contentEl.empty();
-        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");
+        contentEl.createEl("span", { text: this.filename });
+        const div = contentEl.createDiv("");
+        div.addClass("op-scrollable");
+        div.addClass("ls-dialog");
         let diffLength = 0;
         for (const v of this.result.diff) {
             const x1 = v[0];
@@ -137,11 +91,12 @@ export class ConflictResolveModal extends Modal {
                 continue;
             }
             if (x1 == DIFF_DELETE) {
-                this.appendDiffFragment(this.diffView, x2, "deleted");
+                this.appendDiffFragment(div, x2, "deleted");
+                div.createEl("span", { text: x2, cls: "deleted normal conflict-dev-name" });
             } else if (x1 == DIFF_EQUAL) {
-                this.appendDiffFragment(this.diffView, x2, "normal");
+                this.appendDiffFragment(div, x2, "normal");
             } else if (x1 == DIFF_INSERT) {
-                this.appendDiffFragment(this.diffView, x2, "added");
+                this.appendDiffFragment(div, x2, "added");
             }
         }
 
@@ -153,30 +108,24 @@ 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.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));
-        });
+        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";
         if (!this.pluginPickMode) {
-            contentEl.createEl("button", { text: "Concat both" }, (e) => {
-                e.addClass("conflict-action-button");
-                e.addEventListener("click", () => this.sendResponse(LEAVE_TO_SUBSEQUENT));
-            });
+            contentEl.createEl("button", { text: "Concat both" }, (e) =>
+                e.addEventListener("click", () => this.sendResponse(LEAVE_TO_SUBSEQUENT))
+            ).style.marginRight = "4px";
         }
-        contentEl.createEl("button", { text: !this.pluginPickMode ? "Not now" : "Cancel" }, (e) => {
-            e.addClass("conflict-action-button");
-            e.addEventListener("click", () => this.sendResponse(CANCELLED));
-        });
+        contentEl.createEl("button", { text: !this.pluginPickMode ? "Not now" : "Cancel" }, (e) =>
+            e.addEventListener("click", () => this.sendResponse(CANCELLED))
+        ).style.marginRight = "4px";
         if (diffLength > 100 * 1024) {
-            this.diffView.empty();
-            this.diffView.setText("(Too large diff to display)");
+            div.empty();
+            div.innerText = "(Too large diff to display)";
         }
-        this.resetDiffNavigation();
-        this.navigateDiff("next");
     }
 
     sendResponse(result: MergeDialogResult) {

src/modules/features/Log/LogPaneView.ts

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

src/modules/features/ModuleLog.ts

@@ -29,7 +29,7 @@ import { addIcon, debounce, normalizePath, Notice, stringifyYaml, type Workspace
 import { LOG_LEVEL_NOTICE, setGlobalLogFunction } from "octagonal-wheels/common/logger";
 import { LogPaneView, VIEW_TYPE_LOG } from "./Log/LogPaneView.ts";
 import { serialized } from "octagonal-wheels/concurrency/lock";
-import { $msg } from "@lib/common/i18n.ts";
+import { $msg } from "src/lib/src/common/i18n.ts";
 import { P2PLogCollector } from "@/lib/src/replication/trystero/P2PLogCollector.ts";
 import type { LiveSyncCore } from "../../main.ts";
 import { LiveSyncError } from "@lib/common/LSError.ts";

src/modules/features/SettingDialogue/LiveSyncSetting.ts

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

src/modules/features/SetupManager.ts

@@ -7,7 +7,7 @@ import {
     REMOTE_MINIO,
     REMOTE_P2P,
 } from "../../lib/src/common/types.ts";
-import { isObjectDifferent } from "@lib/common/utils.ts";
+import { generatePatchObj, isObjectDifferent } from "../../lib/src/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,7 +23,6 @@ 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
@@ -195,24 +194,8 @@ 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);
     }
@@ -302,9 +285,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);

styles.css

@@ -17,10 +17,6 @@
     min-width: 5em;
 }
 
-.conflict-action-button {
-    margin-right: 4px;
-}
-
 .op-scrollable {
     overflow-y: scroll;
     /* min-height: 280px; */
@@ -171,7 +167,7 @@ body {
 
 .sls-setting-menu-buttons {
     border: 1px solid var(--sls-col-warn);
-    /* padding: 2px; */
+    padding: 2px;
     margin: 1px;
     border-radius: 4px;
     background-image: linear-gradient(-45deg,
@@ -180,7 +176,7 @@ body {
     background-size: 30px 30px;
     display: flex;
     flex-direction: row;
-    /* justify-content: flex-end; */
+    justify-content: flex-end;
     padding: 0.5em 0.25em;
     justify-content: center;
     align-items: center;
@@ -315,9 +311,9 @@ body {
 
 
 .sls-setting-obsolete {
-    /* background-image: linear-gradient(-45deg,
+    background-image: linear-gradient(-45deg,
             var(--sls-col-warn-stripe1) 25%, var(--sls-col-warn-stripe2) 25%, var(--sls-col-warn-stripe2) 50%,
-            var(--sls-col-warn-stripe1) 50%, var(--sls-col-warn-stripe1) 75%, var(--sls-col-warn-stripe2) 75%, var(--sls-col-warn-stripe2)); */
+            var(--sls-col-warn-stripe1) 50%, var(--sls-col-warn-stripe1) 75%, var(--sls-col-warn-stripe2) 75%, var(--sls-col-warn-stripe2));
     background-image: linear-gradient(-45deg,
             transparent 25%, rgba(var(--background-secondary), 0.1) 25%, rgba(var(--background-secondary), 0.1) 50%, transparent 50%, transparent 75%, rgba(var(--background-secondary), 0.1) 75%, rgba(var(--background-secondary), 0.1));
     background-size: 60px 60px;
@@ -525,48 +521,8 @@ 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;
-}
-
+}

tsconfig.json

@@ -2,6 +2,7 @@
     "extends": "@tsconfig/svelte/tsconfig.json",
     "inlineSourceMap": true,
     "compilerOptions": {
+        "baseUrl": ".",
         "module": "ESNext",
         "target": "ES2018",
         "allowJs": true,
@@ -19,8 +20,8 @@
         "strictBindCallApply": true,
         "strictFunctionTypes": true,
         "paths": {
-            "@/*": ["./src/*"],
-            "@lib/*": ["./src/lib/src/*"]
+            "@/*": ["src/*"],
+            "@lib/*": ["src/lib/src/*"]
         }
     },
     "include": ["**/*.ts", "test/**/*.test.ts", "**/*.unit.spec.ts"],

updates.md

@@ -3,35 +3,6 @@ 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