chore: lint: enable cache and concurrency

Releasing v0.25.70

.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-matrix:couchdb-enc0","test:e2e-matrix:couchdb-enc1","test:e2e-matrix:minio-enc0","test:e2e-matrix:minio-enc1"]'
+              TASK_MATRIX='["test:setup-put-cat","test:mirror","test:push-pull","test:sync-two-local","test:sync-locked-remote","test:p2p-host","test:p2p-peers","test:p2p-sync","test:p2p-three-nodes","test:p2p-upload-download","test:e2e-couchdb","test:e2e-matrix"]'
               ;;
             test:local)
               TASK_MATRIX='["test:setup-put-cat","test:mirror"]'
               ;;
             test:e2e-matrix)
-              TASK_MATRIX='["test:e2e-matrix:couchdb-enc0","test:e2e-matrix:couchdb-enc1","test:e2e-matrix:minio-enc0","test:e2e-matrix:minio-enc1"]'
+              TASK_MATRIX='["test:e2e-matrix"]'
               ;;
             test:p2p-sync)
               TASK_MATRIX='["test:p2p-sync"]'
@@ -55,8 +55,6 @@ jobs:
     needs: prepare
     runs-on: ubuntu-latest
     timeout-minutes: 60
-    env:
-      DENO_DIR: ~/.cache/deno
     strategy:
       fail-fast: false
       matrix:
@@ -72,21 +70,12 @@ 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,4 +30,5 @@ cov_profile/**
 coverage
 src/apps/cli/dist/*
 _testdata/**
-utils/bench/splitResults.csv
+utils/bench/splitResults.csv
+.eslintcache

eslint.config.mjs

@@ -43,7 +43,7 @@ export default defineConfig([
     {
         files: ["**/*.ts"],
         languageOptions: {
-            globals: { ...globals.browser },
+            globals: { ...globals.browser, "PouchDB": "readonly" },
             parser: tsParser,
             parserOptions: {
                 project: "./tsconfig.json",
@@ -79,5 +79,5 @@ export default defineConfig([
             "no-unused-vars": ["error", { argsIgnorePattern: "^_", varsIgnorePattern: "^_" }],
             "obsidianmd/no-plugin-as-component": "off", // Temporary
         },
-    },
+    }
 ]);

manifest.json

@@ -1,10 +1,10 @@
 {
     "id": "obsidian-livesync",
     "name": "Self-hosted LiveSync",
-    "version": "0.25.68",
+    "version": "0.25.70",
     "minAppVersion": "1.7.2",
     "description": "Community implementation of self-hosted livesync. Reflect your vault changes to some other devices immediately. Please make sure to disable other synchronize solutions to avoid content corruption or duplication.",
     "author": "vorotamoroz",
     "authorUrl": "https://github.com/vrtmrz",
     "isDesktopOnly": false
-}
+}

package-lock.json

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

package.json

@@ -1,6 +1,6 @@
 {
     "name": "obsidian-livesync",
-    "version": "0.25.68",
+    "version": "0.25.70",
     "description": "Reflect your vault changes to some other devices immediately. Please make sure to disable other synchronize solutions to avoid content corruption or duplication.",
     "main": "main.js",
     "type": "module",
@@ -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 src",
+        "lint": "eslint --cache --concurrency auto src",
         "svelte-check": "svelte-check --tsconfig ./tsconfig.json",
         "tsc-check": "tsc --noEmit",
         "pretty": "npm run prettyNoWrite -- --write --log-level error",

src/apps/cli/.gitignore

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

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

@@ -1,312 +0,0 @@
-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

@@ -1,223 +0,0 @@
-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

@@ -1,45 +0,0 @@
-#!/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,16 +12,8 @@
         "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: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"
+        "test:e2e-matrix": "deno test --env-file=.test.env -A --no-check test-e2e-two-vaults-matrix.ts"
     },
     "imports": {
         "@std/assert": "jsr:@std/assert@^1.0.13",

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

@@ -39,73 +39,27 @@ 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: { write: (chunk: Uint8Array) => void; close: () => void } | null
+    teeTarget: WritableStream<Uint8Array> | 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 (teeTarget) {
-                    teeTarget.write(value);
+                if (writer) {
+                    await writer.write(value);
                 }
             }
         }
     } finally {
-        if (teeTarget) {
-            teeTarget.close();
+        if (writer) {
+            writer.releaseLock();
         }
         reader.releaseLock();
     }
@@ -122,20 +76,8 @@ async function runNodeCommand(args: string[], stdinData?: Uint8Array): Promise<C
         stderr: "piped",
     }).spawn();
 
-    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
-    );
+    const stdoutPromise = collectStream(child.stdout, TEE_ENABLED ? Deno.stdout.writable : null);
+    const stderrPromise = collectStream(child.stderr, TEE_ENABLED ? Deno.stderr.writable : null);
 
     if (stdinData) {
         const w = child.stdin.getWriter();

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

@@ -1,123 +0,0 @@
-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,11 +14,6 @@ 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
@@ -32,53 +27,29 @@ function parseCommand(command: string): { bin: string; prefix: string[] } {
     return { bin: parts[0], prefix: parts.slice(1) };
 }
 
-async function collectStream(
-    stream: ReadableStream<Uint8Array>,
-    teeTarget: ((chunk: Uint8Array) => void) | null
-): Promise<Uint8Array> {
-    const reader = stream.getReader();
-    const chunks: Uint8Array[] = [];
-    try {
-        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 }> {
+    const cmd = new Deno.Command(bin, {
+        args,
+        stdin: "null",
+        stdout: "piped",
+        stderr: "piped",
+    });
     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 { code, stdout, stderr } = await cmd.output();
         const dec = new TextDecoder();
         const result = {
-            code: status.code,
+            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) {
@@ -188,73 +159,6 @@ 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));
 }
@@ -331,8 +235,8 @@ const MINIO_IMAGE = "minio/minio";
 const MINIO_MC_IMAGE = "minio/mc";
 
 export async function stopCouchdb(): Promise<void> {
-    await stopAndRemoveContainer(COUCHDB_CONTAINER);
-    untrackContainer(COUCHDB_CONTAINER);
+    await docker("stop", COUCHDB_CONTAINER);
+    await docker("rm", COUCHDB_CONTAINER);
 }
 
 /**
@@ -361,7 +265,6 @@ 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);
@@ -462,8 +365,8 @@ function shQuote(value: string): string {
 }
 
 export async function stopMinio(): Promise<void> {
-    await stopAndRemoveContainer(MINIO_CONTAINER);
-    untrackContainer(MINIO_CONTAINER);
+    await docker("stop", MINIO_CONTAINER);
+    await docker("rm", MINIO_CONTAINER);
 }
 
 async function initMinioBucket(
@@ -543,7 +446,6 @@ export async function startMinio(
         "--console-address",
         ":9001"
     );
-    trackContainer(MINIO_CONTAINER);
 
     console.log(`[INFO] initialising MinIO test bucket: ${bucket}`);
     let initialised = false;
@@ -591,8 +493,8 @@ EOF
 exec /app/strfry --config /tmp/strfry.conf relay`;
 
 export async function stopP2pRelay(): Promise<void> {
-    await stopAndRemoveContainer(P2P_RELAY_CONTAINER);
-    untrackContainer(P2P_RELAY_CONTAINER);
+    await docker("stop", P2P_RELAY_CONTAINER);
+    await docker("rm", P2P_RELAY_CONTAINER);
 }
 
 /**
@@ -621,7 +523,6 @@ 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

@@ -1,49 +0,0 @@
-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,26 +1,11 @@
 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/)
@@ -35,55 +20,28 @@ export async function discoverPeer(
     timeoutSeconds: number,
     targetPeer?: string
 ): Promise<PeerEntry> {
-    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] };
-            }
-        }
-
-        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}`
-        );
+    const result = await runCli(vaultDir, "--settings", settingsFile, "p2p-peers", String(timeoutSeconds));
+    if (result.code !== 0) {
+        throw new Error(`p2p-peers failed\n${result.combined}`);
     }
-
-    throw new Error(`No peers discovered\n${lastCombined}`);
+    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] };
+        }
+        throw new Error(`No peers discovered\n${result.combined}`);
+    }
+    return peers[0];
 }
 
 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,9 +9,6 @@ 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");
@@ -27,16 +24,15 @@ 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, hostPeerName, passphrase);
-        await applyP2pTestTweaks(clientSettings, clientPeerName, passphrase);
+        await applyP2pTestTweaks(hostSettings, "p2p-host", passphrase);
+        await applyP2pTestTweaks(clientSettings, "p2p-client", 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, hostPeerName);
+            const peer = await discoverPeer(clientVault, clientSettings, timeoutSeconds);
             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,9 +11,6 @@ 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");
@@ -29,8 +26,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, hostPeerName, passphrase);
-        await applyP2pTestTweaks(clientSettings, clientPeerName, passphrase);
+        await applyP2pTestTweaks(hostSettings, "p2p-host", passphrase);
+        await applyP2pTestTweaks(clientSettings, "p2p-client", passphrase);
 
         const host = startCliInBackground(hostVault, "--settings", hostSettings, "p2p-host");
         try {
@@ -39,7 +36,7 @@ Deno.test("p2p-sync: discovers peer and completes sync", async () => {
                 clientVault,
                 clientSettings,
                 peersTimeout,
-                Deno.env.get("TARGET_PEER") ?? hostPeerName
+                Deno.env.get("TARGET_PEER") ?? undefined
             );
             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, applyP2pTestTweaks, initSettingsFile } from "./helpers/settings.ts";
+import { applyP2pSettings, 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,10 +12,6 @@ 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");
@@ -30,21 +26,16 @@ Deno.test("p2p: three nodes detect and resolve conflicts", async () => {
 
     const relayStarted = await maybeStartLocalRelay(relay);
     try {
-        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);
+        for (const settings of [settingsA, settingsB, settingsC]) {
+            await initSettingsFile(settings);
+            await applyP2pSettings(settings, roomId, passphrase, appId, relay);
+        }
 
         const host = startCliInBackground(vaultA, "--settings", settingsA, "p2p-host");
         try {
             await host.waitUntilContains("P2P host is running", 20000);
-            const peerFromB = await discoverPeer(vaultB, settingsB, peersTimeout, hostPeerName);
-            const peerFromC = await discoverPeer(vaultC, settingsC, peersTimeout, hostPeerName);
+            const peerFromB = await discoverPeer(vaultB, settingsB, peersTimeout);
+            const peerFromC = await discoverPeer(vaultC, settingsC, peersTimeout);
             const targetPath = "p2p/conflicted-from-two-clients.txt";
 
             await runCliWithInputOrFail("from-client-b-v1\n", vaultB, "--settings", settingsB, "put", targetPath);

src/features/P2PSync/P2PReplicator/P2PServerStatusCard.svelte

@@ -24,6 +24,7 @@
     let serverInfo = $state<P2PServerInfo | undefined>(undefined);
     let replicatorStatus = $state<P2PReplicatorStatus | undefined>(undefined);
     let roomSuffix = $state<string>(extractP2PRoomSuffix(core?.services.setting.currentSettings()?.P2P_roomID ?? ""));
+    let useDiagRTC = $state<boolean>(core?.services.setting.currentSettings()?.P2P_useDiagRTC ?? false);
 
     async function requestServerStatus() {
         await Promise.resolve(liveSyncReplicator.requestStatus());
@@ -48,6 +49,18 @@
         }
     }
 
+    async function toggleDiagRTC() {
+        if (!core) {
+            return;
+        }
+        const next = !useDiagRTC;
+        await core.services.setting.updateSettings((settings) => {
+            settings.P2P_useDiagRTC = next;
+            return settings;
+        }, true);
+        useDiagRTC = next;
+    }
+
     onMount(() => {
         const unsubscribe = eventHub.onEvent(EVENT_SERVER_STATUS, (status) => {
             serverInfo = status;
@@ -58,6 +71,7 @@
         });
         const unsubscribeSettings = eventHub.onEvent(EVENT_SETTING_SAVED, (settings) => {
             roomSuffix = extractP2PRoomSuffix(settings?.P2P_roomID ?? "");
+            useDiagRTC = settings?.P2P_useDiagRTC ?? false;
         });
 
         fireAndForget(async () => {
@@ -131,6 +145,48 @@
         </button>
     </div>
     {/if}
+
+    {#if core}
+    <div class="status-item status-action diag-toggle-row">
+        <label class="broadcast-label" for="diag-toggle">
+            🕵️ Diag
+        </label>
+        <button
+            id="diag-toggle"
+            class="broadcast-button {useDiagRTC ? 'is-on' : 'is-off'}"
+            onclick={toggleDiagRTC}
+            title={useDiagRTC
+                ? 'Diagnostic RTCPeerConnection is enabled'
+                : 'Use Diagnostic RTCPeerConnection for statistics'}
+        >
+            {useDiagRTC ? 'On' : 'Off'}
+        </button>
+    </div>
+    {/if}
+
+    {#if serverInfo}
+        <div class="diag-section">
+            <h4>Stats</h4>
+            <div class="diag-grid">
+                <div class="diag-item">
+                    <span>Incoming:</span>
+                    <span>{serverInfo.diag.totalNewConnections}</span>
+                </div>
+                <div class="diag-item">
+                    <span>Connected:</span>
+                    <span>{serverInfo.diag.totalSuccessfulConnections}</span>
+                </div>
+                <div class="diag-item">
+                    <span>Failed:</span>
+                    <span>{serverInfo.diag.totalFailedConnections}</span>
+                </div>
+                <div class="diag-item">
+                    <span>Closed:</span>
+                    <span>{serverInfo.diag.totalClosedConnections}</span>
+                </div>
+            </div>
+        </div>
+    {/if}
 </div>
 
 <style>
@@ -190,6 +246,11 @@
         margin-top: 0.25rem;
     }
 
+    .diag-toggle-row {
+        align-items: center;
+        margin-top: 0.25rem;
+    }
+
     .broadcast-label {
         font-size: 0.9rem;
         color: var(--text-normal);
@@ -221,4 +282,29 @@
         background-color: var(--interactive-hover);
         color: var(--text-normal);
     }
+
+    .diag-section {
+        border-top: 1px solid var(--divider-color);
+        margin-top: 0.75rem;
+        padding-top: 0.75rem;
+    }
+
+    .diag-section h4 {
+        margin: 0 0 0.5rem 0;
+        font-size: 0.9rem;
+        font-weight: 600;
+    }
+
+    .diag-grid {
+        display: grid;
+        grid-template-columns: repeat(auto-fit, minmax(130px, 1fr));
+        gap: 0.35rem 0.75rem;
+    }
+
+    .diag-item {
+        display: flex;
+        justify-content: space-between;
+        font-size: 0.85rem;
+        gap: 0.5rem;
+    }
 </style>

src/modules/features/DocumentHistory/DocumentHistoryModal.ts

@@ -56,6 +56,7 @@ export class DocumentHistoryModal extends Modal {
     info!: HTMLDivElement;
     fileInfo!: HTMLDivElement;
     showDiff = false;
+    diffOnly = false;
     id?: DocumentID;
 
     file: FilePathWithPrefix;
@@ -70,6 +71,15 @@ export class DocumentHistoryModal extends Modal {
     currentDiffIndex = -1;
     diffNavContainer!: HTMLDivElement;
     diffNavIndicator!: HTMLSpanElement;
+    diffOnlyLabel!: HTMLLabelElement;
+
+    // Search state
+    searchKeyword = "";
+    searchResults: { rev: string; index: number; matchType: "Content" | "Diff" }[] = [];
+    currentSearchIndex = -1;
+    searchResultIndicator!: HTMLSpanElement;
+    searchProgressIndicator!: HTMLSpanElement;
+    searchTimeout: number | null = null;
 
     constructor(
         app: App,
@@ -88,9 +98,12 @@ export class DocumentHistoryModal extends Modal {
         if (!file && id) {
             this.file = this.services.path.id2path(id);
         }
-        if (localStorage.getItem("ols-history-highlightdiff") == "1") {
+        if (this.app.loadLocalStorage("ols-history-highlightdiff") == "1") {
             this.showDiff = true;
         }
+        if (this.app.loadLocalStorage("ols-history-diffonly") == "1") {
+            this.diffOnly = true;
+        }
     }
 
     async loadFile(initialRev?: string) {
@@ -151,17 +164,48 @@ export class DocumentHistoryModal extends Modal {
     }
 
     appendTextDiff(diff: [number, string][]) {
+        let hasOmitted = false;
         for (const [operation, text] of diff) {
             if (operation == DIFF_DELETE) {
-                this.contentView.createSpan({ text, cls: "history-deleted" });
+                this.appendSearchHighlightedText(this.contentView.createSpan({ cls: "history-deleted" }), text);
+                hasOmitted = false;
             } else if (operation == DIFF_EQUAL) {
-                this.contentView.createSpan({ text, cls: "history-normal" });
+                if (this.diffOnly) {
+                    if (!hasOmitted) {
+                        this.contentView.appendText("\n...\n");
+                        hasOmitted = true;
+                    }
+                } else {
+                    this.appendSearchHighlightedText(this.contentView.createSpan({ cls: "history-normal" }), text);
+                }
             } else if (operation == DIFF_INSERT) {
-                this.contentView.createSpan({ text, cls: "history-added" });
+                this.appendSearchHighlightedText(this.contentView.createSpan({ cls: "history-added" }), text);
+                hasOmitted = false;
             }
         }
     }
 
+    appendSearchHighlightedText(container: HTMLElement, text: string) {
+        if (!this.searchKeyword) {
+            container.appendText(text);
+            return;
+        }
+        const escapedKeyword = this.searchKeyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const regex = new RegExp(escapedKeyword, "gi");
+        let lastIndex = 0;
+        for (const match of text.matchAll(regex)) {
+            const index = match.index ?? 0;
+            if (index > lastIndex) {
+                container.appendText(text.slice(lastIndex, index));
+            }
+            container.createEl("mark", { text: match[0] });
+            lastIndex = index + match[0].length;
+        }
+        if (lastIndex < text.length) {
+            container.appendText(text.slice(lastIndex));
+        }
+    }
+
     appendImageDiff(baseSrc: string, overlaySrc?: string) {
         const wrap = this.contentView.createDiv({ cls: "ls-imgdiff-wrap" });
         const overlay = wrap.createDiv({ cls: "overlay" });
@@ -258,7 +302,7 @@ export class DocumentHistoryModal extends Modal {
                     if (this.currentDeleted) {
                         this.appendDeletedNotice();
                     }
-                    this.contentView.appendText(w1data);
+                    this.appendSearchHighlightedText(this.contentView, w1data);
                 }
             }
         }
@@ -266,6 +310,11 @@ export class DocumentHistoryModal extends Modal {
         this.resetDiffNavigation();
         if (this.showDiff) {
             this.navigateDiff("next");
+        } else if (this.searchKeyword) {
+            const firstMark = this.contentView.querySelector("mark");
+            if (firstMark) {
+                firstMark.scrollIntoView({ behavior: "smooth", block: "center" });
+            }
         }
     }
 
@@ -293,7 +342,7 @@ export class DocumentHistoryModal extends Modal {
         target.classList.add("diff-focused");
         target.scrollIntoView({ behavior: "smooth", block: "center" });
 
-        this.diffNavIndicator.textContent = `${this.currentDiffIndex + 1}/${diffElements.length}`;
+        this.diffNavIndicator.setText(`${this.currentDiffIndex + 1}/${diffElements.length}`);
     }
 
     /**
@@ -304,9 +353,9 @@ export class DocumentHistoryModal extends Modal {
         if (this.diffNavIndicator) {
             if (this.showDiff) {
                 const diffElements = this.contentView.querySelectorAll(".history-added, .history-deleted");
-                this.diffNavIndicator.textContent = diffElements.length > 0 ? `0/${diffElements.length}` : "\u2014";
+                this.diffNavIndicator.setText(diffElements.length > 0 ? `0/${diffElements.length}` : "\u2014");
             } else {
-                this.diffNavIndicator.textContent = "\u2014";
+                this.diffNavIndicator.setText("\u2014");
             }
         }
         this.updateDiffNavVisibility();
@@ -319,6 +368,117 @@ export class DocumentHistoryModal extends Modal {
         if (this.diffNavContainer) {
             this.diffNavContainer.style.display = this.showDiff ? "flex" : "none";
         }
+        if (this.diffOnlyLabel) {
+            this.diffOnlyLabel.style.display = this.showDiff ? "inline-block" : "none";
+        }
+    }
+
+    /**
+     * Search through the last 100 revisions for the given keyword.
+     */
+    async performSearch(keyword: string) {
+        this.searchKeyword = keyword;
+        this.searchResults = [];
+        this.currentSearchIndex = -1;
+
+        if (!keyword) {
+            this.searchResultIndicator.setText("");
+            this.searchProgressIndicator.setText("");
+            return;
+        }
+
+        const db = this.core.localDatabase;
+        const limit = 100;
+        const totalRevs = this.revs_info.length;
+        const end = Math.min(totalRevs, limit);
+
+        this.searchProgressIndicator.setText("Searching...");
+
+        const dmp = new diff_match_patch();
+
+        // 0 is the newest, higher index is older.
+        for (let i = 0; i < end; i++) {
+            const revInfo = this.revs_info[i];
+            const rev = revInfo.rev;
+
+            this.searchProgressIndicator.setText(`Searching ${i + 1}/${end}...`);
+
+            const doc = await db.getDBEntry(this.file, { rev: rev }, false, false, true);
+            if (doc === false) continue;
+
+            const content = readDocument(doc);
+            if (typeof content !== "string") continue;
+
+            const keywordLower = keyword.toLocaleLowerCase();
+
+            // Search in content
+            if (content.toLocaleLowerCase().includes(keywordLower)) {
+                this.searchResults.push({ rev, index: i, matchType: "Content" });
+                this.updateSearchUI();
+                continue;
+            }
+
+            // Search in diff (from older version to this version)
+            // Older version is at i + 1
+            if (i < totalRevs - 1) {
+                const olderRev = this.revs_info[i + 1].rev;
+                const olderDoc = await db.getDBEntry(this.file, { rev: olderRev }, false, false, true);
+                if (olderDoc !== false) {
+                    const olderContent = readDocument(olderDoc);
+                    if (typeof olderContent === "string") {
+                        const diffs = dmp.diff_main(olderContent, content);
+                        let foundInDiff = false;
+                        for (const d of diffs) {
+                            if (
+                                (d[0] === DIFF_INSERT || d[0] === DIFF_DELETE) &&
+                                d[1].toLocaleLowerCase().includes(keywordLower)
+                            ) {
+                                foundInDiff = true;
+                                break;
+                            }
+                        }
+                        if (foundInDiff) {
+                            this.searchResults.push({ rev, index: i, matchType: "Diff" });
+                            this.updateSearchUI();
+                        }
+                    }
+                }
+            }
+        }
+
+        this.searchProgressIndicator.setText("Done");
+        this.updateSearchUI();
+    }
+
+    updateSearchUI() {
+        if (this.searchResults.length === 0) {
+            this.searchResultIndicator.setText(this.searchKeyword ? "No matches found" : "");
+        } else {
+            const current = this.currentSearchIndex >= 0 ? this.currentSearchIndex + 1 : 0;
+            this.searchResultIndicator.setText(`${current}/${this.searchResults.length} matches`);
+        }
+    }
+
+    navigateSearch(direction: "prev" | "next") {
+        if (this.searchResults.length === 0) return;
+
+        if (direction === "next") {
+            this.currentSearchIndex = (this.currentSearchIndex + 1) % this.searchResults.length;
+        } else {
+            this.currentSearchIndex =
+                this.currentSearchIndex <= 0 ? this.searchResults.length - 1 : this.currentSearchIndex - 1;
+        }
+
+        const match = this.searchResults[this.currentSearchIndex];
+        this.range.value = `${this.revs_info.length - 1 - match.index}`;
+        void scheduleOnceIfDuplicated("loadRevs", () => this.loadRevs());
+        this.updateSearchUI();
+
+        // If it's a diff match, make sure Highlight diff is on
+        if (match.matchType === "Diff" && !this.showDiff) {
+            // We could auto-enable it, but maybe just notify the user?
+            // For now, let's just let the user toggle it if they want to see the diff.
+        }
     }
 
     override onOpen() {
@@ -327,6 +487,42 @@ export class DocumentHistoryModal extends Modal {
         contentEl.empty();
         this.fileInfo = contentEl.createDiv("");
         this.fileInfo.addClass("op-info");
+
+        // Search Row
+        const searchRow = contentEl.createDiv("");
+        searchRow.addClass("op-info");
+        searchRow.addClass("search-row");
+        searchRow.addClass("history-search-row");
+
+        const searchInput = searchRow.createEl("input", {
+            type: "text",
+            placeholder: "Search in history (last 100)...",
+        });
+        searchInput.addClass("history-search-input");
+        searchInput.addEventListener("input", () => {
+            if (this.searchTimeout) {
+                clearTimeout(this.searchTimeout);
+            }
+            this.searchTimeout = window.setTimeout(() => {
+                void this.performSearch(searchInput.value);
+            }, 500);
+        });
+
+        searchRow.createEl("button", { text: "\u25B2" }, (e) => {
+            e.title = "Previous match";
+            e.addEventListener("click", () => this.navigateSearch("prev"));
+        });
+        searchRow.createEl("button", { text: "\u25BC" }, (e) => {
+            e.title = "Next match";
+            e.addEventListener("click", () => this.navigateSearch("next"));
+        });
+
+        this.searchResultIndicator = searchRow.createEl("span", { text: "" });
+        this.searchResultIndicator.addClass("history-search-result-indicator");
+
+        this.searchProgressIndicator = searchRow.createEl("span", { text: "" });
+        this.searchProgressIndicator.addClass("history-search-progress-indicator");
+
         const divView = contentEl.createDiv("");
         divView.addClass("op-flex");
 
@@ -342,24 +538,43 @@ export class DocumentHistoryModal extends Modal {
         const diffOptionsRow = contentEl.createDiv("");
         diffOptionsRow.addClass("op-info");
         diffOptionsRow.addClass("diff-options-row");
+        diffOptionsRow.addClass("history-diff-options-row");
 
-        diffOptionsRow.createEl("label", {}, (label) => {
-            label.appendChild(
-                createEl("input", { type: "checkbox" }, (checkbox) => {
-                    if (this.showDiff) {
-                        checkbox.checked = true;
-                    }
-                    checkbox.addEventListener("input", (evt: any) => {
-                        this.showDiff = checkbox.checked;
-                        localStorage.setItem("ols-history-highlightdiff", this.showDiff == true ? "1" : "");
-                        this.updateDiffNavVisibility();
-                        void scheduleOnceIfDuplicated("loadRevs", () => this.loadRevs());
-                    });
-                })
-            );
+        const highlightDiffContainer = diffOptionsRow.createDiv("");
+        highlightDiffContainer.addClass("history-highlight-diff-container");
+
+        highlightDiffContainer.createEl("label", {}, (label) => {
+            label.addClass("history-highlight-diff-label");
+            label.createEl("input", { type: "checkbox" }, (checkbox) => {
+                if (this.showDiff) {
+                    checkbox.checked = true;
+                }
+                checkbox.addEventListener("input", (evt: any) => {
+                    this.showDiff = checkbox.checked;
+                    this.app.saveLocalStorage("ols-history-highlightdiff", this.showDiff == true ? "1" : null);
+                    this.updateDiffNavVisibility();
+                    void scheduleOnceIfDuplicated("loadRevs", () => this.loadRevs());
+                });
+            });
             label.appendText("Highlight diff");
         });
 
+        const diffOnlyLabel = diffOptionsRow.createEl("label", {});
+        diffOnlyLabel.createEl("input", { type: "checkbox" }, (checkbox) => {
+            if (this.diffOnly) {
+                checkbox.checked = true;
+            }
+            checkbox.addEventListener("input", (evt: any) => {
+                this.diffOnly = checkbox.checked;
+                this.app.saveLocalStorage("ols-history-diffonly", this.diffOnly == true ? "1" : null);
+                void scheduleOnceIfDuplicated("loadRevs", () => this.loadRevs());
+            });
+        });
+        diffOnlyLabel.appendText("Diff only");
+        diffOnlyLabel.addClass("diff-only-label");
+        diffOnlyLabel.style.display = this.showDiff ? "inline-block" : "none";
+        this.diffOnlyLabel = diffOnlyLabel;
+
         // Diff navigation buttons
         this.diffNavContainer = diffOptionsRow.createDiv("");
         this.diffNavContainer.addClass("diff-nav");

src/modules/features/InteractiveConflictResolving/ConflictResolveModal.ts

@@ -27,6 +27,9 @@ export class ConflictResolveModal extends Modal {
     localName: string = "Base";
     remoteName: string = "Conflicted";
     offEvent?: ReturnType<typeof eventHub.onEvent>;
+    currentDiffIndex = -1;
+    diffView!: HTMLDivElement;
+    diffNavIndicator!: HTMLSpanElement;
 
     constructor(app: App, filename: string, diff: diff_result, pluginPickMode?: boolean, remoteName?: string) {
         super(app);
@@ -47,7 +50,7 @@ export class ConflictResolveModal extends Modal {
         const lines = text.split("\n");
         lines.forEach((line, index) => {
             const span = container.createSpan({ cls });
-            span.textContent = line;
+            span.setText(line);
             if (index < lines.length - 1) {
                 container.createSpan({ cls: "ls-mark-cr" });
                 container.createEl("br");
@@ -62,6 +65,33 @@ export class ConflictResolveModal extends Modal {
         container.createEl("br");
     }
 
+    navigateDiff(direction: "prev" | "next") {
+        const diffElements = this.diffView.querySelectorAll(".added, .deleted");
+        if (diffElements.length === 0) return;
+
+        const prevFocused = this.diffView.querySelector(".diff-focused");
+        if (prevFocused) {
+            prevFocused.classList.remove("diff-focused");
+        }
+
+        if (direction === "next") {
+            this.currentDiffIndex = (this.currentDiffIndex + 1) % diffElements.length;
+        } else {
+            this.currentDiffIndex = this.currentDiffIndex <= 0 ? diffElements.length - 1 : this.currentDiffIndex - 1;
+        }
+
+        const target = diffElements[this.currentDiffIndex];
+        target.classList.add("diff-focused");
+        target.scrollIntoView({ behavior: "smooth", block: "center" });
+        this.diffNavIndicator.setText(`${this.currentDiffIndex + 1}/${diffElements.length}`);
+    }
+
+    resetDiffNavigation() {
+        this.currentDiffIndex = -1;
+        const diffElements = this.diffView.querySelectorAll(".added, .deleted");
+        this.diffNavIndicator.setText(diffElements.length > 0 ? `0/${diffElements.length}` : "\u2014");
+    }
+
     override onOpen() {
         const { contentEl } = this;
         // Send cancel signal for the previous merge dialogue
@@ -78,10 +108,26 @@ export class ConflictResolveModal extends Modal {
         // sendValue("close-resolve-conflict:" + this.filename, false);
         this.titleEl.setText(this.title);
         contentEl.empty();
-        contentEl.createEl("span", { text: this.filename });
-        const div = contentEl.createDiv("");
-        div.addClass("op-scrollable");
-        div.addClass("ls-dialog");
+        const diffOptionsRow = contentEl.createDiv("");
+        diffOptionsRow.addClass("diff-options-row");
+        diffOptionsRow.createEl("span", { text: this.filename });
+
+        const diffNavContainer = diffOptionsRow.createDiv("");
+        diffNavContainer.addClass("diff-nav");
+        diffNavContainer.createEl("button", { text: "\u25B2 Prev" }, (e) => {
+            e.addClass("diff-nav-btn");
+            e.addEventListener("click", () => this.navigateDiff("prev"));
+        });
+        diffNavContainer.createEl("button", { text: "\u25BC Next" }, (e) => {
+            e.addClass("diff-nav-btn");
+            e.addEventListener("click", () => this.navigateDiff("next"));
+        });
+        this.diffNavIndicator = diffNavContainer.createEl("span", { text: "\u2014" });
+        this.diffNavIndicator.addClass("diff-nav-indicator");
+
+        this.diffView = contentEl.createDiv("");
+        this.diffView.addClass("op-scrollable");
+        this.diffView.addClass("ls-dialog");
         let diffLength = 0;
         for (const v of this.result.diff) {
             const x1 = v[0];
@@ -91,12 +137,11 @@ export class ConflictResolveModal extends Modal {
                 continue;
             }
             if (x1 == DIFF_DELETE) {
-                this.appendDiffFragment(div, x2, "deleted");
-                div.createEl("span", { text: x2, cls: "deleted normal conflict-dev-name" });
+                this.appendDiffFragment(this.diffView, x2, "deleted");
             } else if (x1 == DIFF_EQUAL) {
-                this.appendDiffFragment(div, x2, "normal");
+                this.appendDiffFragment(this.diffView, x2, "normal");
             } else if (x1 == DIFF_INSERT) {
-                this.appendDiffFragment(div, x2, "added");
+                this.appendDiffFragment(this.diffView, x2, "added");
             }
         }
 
@@ -108,24 +153,30 @@ export class ConflictResolveModal extends Modal {
             new Date(this.result.right.mtime).toLocaleString() + (this.result.right.deleted ? " (Deleted)" : "");
         this.appendVersionInfo(div2, "deleted", this.localName, date1);
         this.appendVersionInfo(div2, "added", this.remoteName, date2);
-        contentEl.createEl("button", { text: `Use ${this.localName}` }, (e) =>
-            e.addEventListener("click", () => this.sendResponse(this.result.right.rev))
-        ).style.marginRight = "4px";
-        contentEl.createEl("button", { text: `Use ${this.remoteName}` }, (e) =>
-            e.addEventListener("click", () => this.sendResponse(this.result.left.rev))
-        ).style.marginRight = "4px";
+        contentEl.createEl("button", { text: `Use ${this.localName}` }, (e) => {
+            e.addClass("conflict-action-button");
+            e.addEventListener("click", () => this.sendResponse(this.result.right.rev));
+        });
+        contentEl.createEl("button", { text: `Use ${this.remoteName}` }, (e) => {
+            e.addClass("conflict-action-button");
+            e.addEventListener("click", () => this.sendResponse(this.result.left.rev));
+        });
         if (!this.pluginPickMode) {
-            contentEl.createEl("button", { text: "Concat both" }, (e) =>
-                e.addEventListener("click", () => this.sendResponse(LEAVE_TO_SUBSEQUENT))
-            ).style.marginRight = "4px";
+            contentEl.createEl("button", { text: "Concat both" }, (e) => {
+                e.addClass("conflict-action-button");
+                e.addEventListener("click", () => this.sendResponse(LEAVE_TO_SUBSEQUENT));
+            });
         }
-        contentEl.createEl("button", { text: !this.pluginPickMode ? "Not now" : "Cancel" }, (e) =>
-            e.addEventListener("click", () => this.sendResponse(CANCELLED))
-        ).style.marginRight = "4px";
+        contentEl.createEl("button", { text: !this.pluginPickMode ? "Not now" : "Cancel" }, (e) => {
+            e.addClass("conflict-action-button");
+            e.addEventListener("click", () => this.sendResponse(CANCELLED));
+        });
         if (diffLength > 100 * 1024) {
-            div.empty();
-            div.innerText = "(Too large diff to display)";
+            this.diffView.empty();
+            this.diffView.setText("(Too large diff to display)");
         }
+        this.resetDiffNavigation();
+        this.navigateDiff("next");
     }
 
     sendResponse(result: MergeDialogResult) {

src/modules/features/SetupManager.ts

@@ -7,7 +7,7 @@ import {
     REMOTE_MINIO,
     REMOTE_P2P,
 } from "../../lib/src/common/types.ts";
-import { generatePatchObj, isObjectDifferent } from "../../lib/src/common/utils.ts";
+import { isObjectDifferent } from "@lib/common/utils.ts";
 import Intro from "./SetupWizard/dialogs/Intro.svelte";
 import SelectMethodNewUser from "./SetupWizard/dialogs/SelectMethodNewUser.svelte";
 import SelectMethodExisting from "./SetupWizard/dialogs/SelectMethodExisting.svelte";
@@ -23,6 +23,7 @@ import SetupRemoteP2P from "./SetupWizard/dialogs/SetupRemoteP2P.svelte";
 import SetupRemoteE2EE from "./SetupWizard/dialogs/SetupRemoteE2EE.svelte";
 import { decodeSettingsFromQRCodeData } from "../../lib/src/API/processSetting.ts";
 import { AbstractModule } from "../AbstractModule.ts";
+import { ConnectionStringParser } from "@lib/common/ConnectionString.ts";
 
 /**
  * User modes for onboarding and setup
@@ -194,8 +195,24 @@ export class SetupManager extends AbstractModule {
             return await this.onOnboard(userMode);
         }
         const newSetting = { ...currentSetting, ...p2pConf } as ObsidianLiveSyncSettings;
+        // Apply remoteConfigurations
+        if (newSetting.P2P_ActiveRemoteConfigurationId) {
+            const id = newSetting.P2P_ActiveRemoteConfigurationId;
+            const merged = {
+                ...newSetting,
+                ...p2pConf,
+            } as ObsidianLiveSyncSettings;
+            const uri = ConnectionStringParser.serialize({ type: "p2p", settings: merged });
+            newSetting.remoteConfigurations[id] = {
+                ...newSetting.remoteConfigurations[id],
+                uri,
+                isEncrypted: false,
+            };
+            newSetting.P2P_ActiveRemoteConfigurationId = id;
+        }
         if (activate) {
             newSetting.remoteType = REMOTE_P2P;
+            newSetting.activeConfigurationId = newSetting.P2P_ActiveRemoteConfigurationId;
         }
         return await this.onConfirmApplySettingsFromWizard(newSetting, userMode, activate);
     }
@@ -285,9 +302,9 @@ export class SetupManager extends AbstractModule {
                 this._log("No changes in settings detected. Skipping applying settings from wizard.", LOG_LEVEL_NOTICE);
                 return true;
             }
-            const patch = generatePatchObj(this.settings, newConf);
-            console.log(`Changes:`);
-            console.dir(patch);
+            // const patch = generatePatchObj(this.settings, newConf);
+            // console.log(`Changes:`);
+            // console.dir(patch);
             if (!activate) {
                 extra();
                 await this.applySetting(newConf, UserMode.ExistingUser);

styles.css

@@ -17,6 +17,10 @@
     min-width: 5em;
 }
 
+.conflict-action-button {
+    margin-right: 4px;
+}
+
 .op-scrollable {
     overflow-y: scroll;
     /* min-height: 280px; */
@@ -521,8 +525,48 @@ div.workspace-leaf-content[data-type=bases]  .livesync-status {
     text-align: center;
 }
 
+.diff-only-label {
+    margin-left: 10px;
+}
+
+.history-search-row {
+    display: flex;
+    gap: 5px;
+    align-items: center;
+    margin-bottom: 10px;
+}
+
+.history-search-input {
+    flex-grow: 1;
+}
+
+.history-search-result-indicator {
+    font-size: 0.8em;
+    min-width: 80px;
+}
+
+.history-search-progress-indicator {
+    font-size: 0.8em;
+    color: var(--text-muted);
+}
+
+.history-diff-options-row {
+    justify-content: space-between;
+}
+
+.history-highlight-diff-container,
+.history-highlight-diff-label {
+    display: flex;
+    align-items: center;
+}
+
+.history-highlight-diff-label {
+    gap: 4px;
+}
+
 .diff-focused {
     outline: 2px solid var(--interactive-accent);
     outline-offset: 1px;
     border-radius: 2px;
-}
+}
+

updates.md

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