@vrtmrz/livesync-commonlib 0.1.19 → 0.1.21

package/dist/replication/trystero/TrysteroReplicator.js

@@ -1,21 +1,45 @@
 import { TweakValuesShouldMatchedTemplate } from "../../common/types.js";
-import { LOG_LEVEL_INFO, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE, Logger } from "octagonal-wheels/common/logger";
+import {
+  LOG_LEVEL_INFO,
+  LOG_LEVEL_NOTICE,
+  LOG_LEVEL_VERBOSE,
+  Logger
+} from "octagonal-wheels/common/logger";
 import { replicateShim } from "../../pouchdb/ReplicatorShim.js";
-import {} from "./types.js";
-import { TrysteroConnection } from "./TrysteroReplicatorP2PConnection.js";
+import { resolveCurrentP2PSettings } from "./types.js";
 import { scheduleOnceIfDuplicated, serialized, skipIfDuplicated } from "octagonal-wheels/concurrency/lock_v2";
 import { delay, fireAndForget } from "octagonal-wheels/promises";
-import { EVENT_P2P_REPLICATOR_PROGRESS, EVENT_P2P_REPLICATOR_STATUS, P2PHost } from "./TrysteroReplicatorP2PServer.js";
+import {
+  EVENT_ADVERTISEMENT_RECEIVED,
+  EVENT_P2P_REPLICATOR_PROGRESS,
+  EVENT_P2P_REPLICATOR_STATUS,
+  P2PHost
+} from "./TrysteroReplicatorP2PServer.js";
 import { encryptWithEphemeralSalt, decryptWithEphemeralSalt } from "octagonal-wheels/encryption/hkdf";
 import { sha1 } from "octagonal-wheels/hash/purejs";
 import { isObjectDifferent } from "octagonal-wheels/object";
 import { getRelaySockets, pauseRelayReconnection, resumeRelayReconnection } from "@trystero-p2p/nostr";
+import { P2PAutomationCoordinator } from "./P2PAutomationCoordinator.js";
+import { compatGlobal } from "../../common/coreEnvFunctions.js";
+import {
+  fromP2PReplicationWireResult,
+  toP2PReplicationWireResult,
+  toP2PWireError
+} from "./P2PReplicationWire.js";
 async function encrypt(data, passphrase) {
   return await encryptWithEphemeralSalt(data, passphrase, true);
 }
 async function decrypt(encryptedData, passphrase) {
   return await decryptWithEphemeralSalt(encryptedData, passphrase);
 }
+const P2P_REPLICATION_COMPLETED = Object.freeze({ status: "completed", ok: true });
+const P2P_REPLICATION_CANCELLED = Object.freeze({ status: "cancelled" });
+function p2pReplicationFailed(error) {
+  return { status: "failed", error };
+}
+function isP2PReplicationCancelled(result) {
+  return result.status === "cancelled";
+}
 async function getHashedStringWithCurrentTime(source) {
   const salt = (~~((/* @__PURE__ */ new Date()).getTime() / 1e3 / 180)).toString(36);
   const salt2 = await sha1(salt);
@@ -23,6 +47,9 @@ async function getHashedStringWithCurrentTime(source) {
 }
 class TrysteroReplicator {
   _env;
+  finiteOperationOwner;
+  disposed = false;
+  fallbackAutomationCoordinator = new P2PAutomationCoordinator();
   server;
   replicationStatus() {
     return {};
@@ -30,6 +57,10 @@ class TrysteroReplicator {
   get settings() {
     return this._env.settings;
   }
+  /** Latest room-local policy settings supplied by the owning host. */
+  get currentSettings() {
+    return resolveCurrentP2PSettings(this._env);
+  }
   get db() {
     return this._env.db;
   }
@@ -45,6 +76,9 @@ class TrysteroReplicator {
   get translate() {
     return this._env.translate;
   }
+  get automationCoordinator() {
+    return this._env.automationCoordinator ?? this.fallbackAutomationCoordinator;
+  }
   async runFiniteReplicationActivity(task) {
     if (this._env.runFiniteReplicationActivity) {
       return await this._env.runFiniteReplicationActivity(task, { label: "replication" });
@@ -54,8 +88,9 @@ class TrysteroReplicator {
   async canStartOrdinaryReplication(showMessage = false) {
     return this._env.canStartOrdinaryReplication ? await this._env.canStartOrdinaryReplication(showMessage) : true;
   }
-  constructor(env, server) {
+  constructor(env, server, finiteOperationOwner) {
     this._env = env;
+    this.finiteOperationOwner = finiteOperationOwner;
     if (server) {
       this.server = server;
       return;
@@ -76,13 +111,19 @@ class TrysteroReplicator {
       if (!this.settings.P2P_relays || this.settings.P2P_relays.length === 0) {
         throw new Error("No relay URIs provided. We need them to establish the P2P connection");
       }
-      this.server = new TrysteroConnection(env);
+      this.server = new P2PHost(env);
     } catch (e) {
       Logger(e instanceof Error ? e.message : "Error while creating TrysteroReplicator", LOG_LEVEL_NOTICE);
       Logger(e, LOG_LEVEL_VERBOSE);
       throw e;
     }
   }
+  async runSessionFiniteOperation(task, callerSignal) {
+    if (this.finiteOperationOwner) {
+      return await this.finiteOperationOwner.runFiniteOperation(task, callerSignal);
+    }
+    return await task(callerSignal);
+  }
   async close() {
     this.requestStatus();
     await this.server?.shutdown();
@@ -92,13 +133,31 @@ class TrysteroReplicator {
     this.requestStatus();
     this.disconnectFromServer();
   }
+  /** Close the transport and release resources owned for this object's lifetime. */
+  async dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    try {
+      await this.close();
+    } finally {
+      this.server?.dispose();
+    }
+  }
   async open() {
+    if (this.disposed) {
+      throw new Error("The P2P Replicator has been disposed.");
+    }
     this.allowReconnection();
-    await this.server?.start([this.getCommands()]);
+    const commands = this.getCommands();
+    await this.server?.start(
+      [commands],
+      () => this.server?.serveCancellationAwareFunction(
+        "reqSync",
+        async ({ signal }, _peerId, fromPeerId) => toP2PReplicationWireResult(await this.handleSynchronisationRequest(fromPeerId, signal))
+      )
+    );
     this.dispatchStatus();
-    if (this.settings.P2P_AutoBroadcast) {
-      this.enableBroadcastChanges();
-    }
+    this.reconcileAutoBroadcast(this.currentSettings.P2P_AutoBroadcast);
   }
   async makeSureOpened() {
     if (!this.server?.isServing) {
@@ -106,19 +165,27 @@ class TrysteroReplicator {
     }
   }
   get autoSyncPeers() {
-    const peers = this.settings.P2P_AutoSyncPeers.split(",").map((e) => e.trim()).filter((e) => e.length > 0).map((e) => e.startsWith("~") ? new RegExp(e.substring(1), "i") : new RegExp(`^${e}$`, "i"));
+    const peers = this.currentSettings.P2P_AutoSyncPeers.split(",").map((e) => e.trim()).filter((e) => e.length > 0).map((e) => e.startsWith("~") ? new RegExp(e.substring(1), "i") : new RegExp(`^${e}$`, "i"));
     return peers;
   }
   get autoWatchPeers() {
-    const peers = this.settings.P2P_AutoWatchPeers.split(",").map((e) => e.trim()).filter((e) => e.length > 0).map((e) => e.startsWith("~") ? new RegExp(e.substring(1), "i") : new RegExp(`^${e}$`, "i"));
+    const peers = this.currentSettings.P2P_AutoWatchPeers.split(",").map((e) => e.trim()).filter((e) => e.length > 0).map((e) => e.startsWith("~") ? new RegExp(e.substring(1), "i") : new RegExp(`^${e}$`, "i"));
     return peers;
   }
   async onNewPeer(peer) {
     const peerName = peer.name;
-    if (this.autoSyncPeers.some((e) => e.test(peerName))) {
-      await this.runFiniteReplicationActivity(() => this.sync(peer.peerId));
+    const shouldAutoSync = this.autoSyncPeers.some((e) => e.test(peerName));
+    const shouldAutoWatch = this.autoWatchPeers.some((e) => e.test(peerName));
+    if (!shouldAutoSync && !shouldAutoWatch) return;
+    const acceptance = await this.server?.evaluatePeerAcceptance(peer.peerId);
+    if (acceptance !== "accepted") return;
+    if (shouldAutoSync) {
+      await this.automationCoordinator.runBaseline(
+        peerName,
+        () => this.runFiniteReplicationActivity(() => this.sync(peer.peerId))
+      );
     }
-    if (this.autoWatchPeers.some((e) => e.test(peerName))) {
+    if (shouldAutoWatch && await this.getRemoteIsBroadcasting(peer.peerId) === true) {
       this.watchPeer(peer.peerId);
     }
   }
@@ -148,15 +215,19 @@ class TrysteroReplicator {
     }
     return allSettings;
   }
+  async handleSynchronisationRequest(fromPeerId, signal) {
+    if (this._onSetup) {
+      return p2pReplicationFailed(new Error("The setup is in progress"));
+    }
+    return await this.runFiniteReplicationActivity(
+      () => signal ? this.replicateFrom(fromPeerId, false, false, false, signal) : this.replicateFrom(fromPeerId)
+    );
+  }
   getCommands() {
     return {
-      reqSync: async (fromPeerId) => {
-        if (this._onSetup) {
-          return { error: new Error("The setup is in progress") };
-        }
-        const result = await this.runFiniteReplicationActivity(() => this.replicateFrom(fromPeerId));
-        return result;
-      },
+      // The wire-visible command deliberately accepts only serialisable
+      // arguments. RpcRoom supplies cancellation context separately.
+      reqSync: async (fromPeerId) => toP2PReplicationWireResult(await this.handleSynchronisationRequest(fromPeerId)),
       "!reqAuth": async (fromPeerId) => {
         return await this.server?.isAcceptablePeer(fromPeerId);
       },
@@ -165,13 +236,13 @@ class TrysteroReplicator {
       },
       onProgress: async (fromPeerId) => {
         if (this._onSetup) {
-          return { error: new Error("The setup is in progress") };
+          return { error: toP2PWireError(new Error("The setup is in progress")) };
         }
         await this.onUpdateDatabase(fromPeerId);
       },
       getAllConfig: async (fromPeerId) => {
         if (this._onSetup) {
-          return { error: new Error("The setup is in progress") };
+          return { error: toP2PWireError(new Error("The setup is in progress")) };
         }
         const passphrase = await skipIfDuplicated(`getAllConfig-${fromPeerId}`, async () => {
           return await this.confirm.askString(
@@ -218,7 +289,7 @@ class TrysteroReplicator {
       },
       requestBroadcasting: async (peerId) => {
         if (this._onSetup) {
-          return { error: new Error("The setup is in progress") };
+          return { error: toP2PWireError(new Error("The setup is in progress")) };
         }
         if (this._isBroadcasting) {
           return true;
@@ -235,7 +306,7 @@ class TrysteroReplicator {
       }
     };
   }
-  async requestAuthenticate(peerId) {
+  async requestAuthenticate(peerId, signal) {
     if (!this.server) return false;
     try {
       const connection = this.server.getConnection(peerId);
@@ -243,7 +314,8 @@ class TrysteroReplicator {
       const r = await connection.invokeRemoteObjectFunction(
         "!reqAuth",
         [selfPeerId],
-        2e4
+        2e4,
+        signal
       );
       return r;
     } catch (e) {
@@ -252,30 +324,34 @@ class TrysteroReplicator {
       return false;
     }
   }
-  // async selectPeer() {
-  //     if (!this.server) return false;
-  //     const knownPeers = this.server.knownAdvertisements;
-  //     if (knownPeers.length === 0) {
-  //         Logger("No known peers", LOG_LEVEL_VERBOSE);
-  //         return false;
-  //     }
-  //     const peers = [...Object.entries(knownPeers)].map(([peerId, info]) => {
-  //         return `${info.peerId}\u2001: (${info.name})`;
-  //     });
-  //     const selectedPeer = await this.confirm.askSelectString("Select a peer to replicate", peers);
-  //     if (selectedPeer) return selectedPeer.split("\u2001")[0];
-  //     return false;
-  // }
   lastSeq = "";
-  async requestSynchroniseToPeer(peerId) {
+  async requestSynchroniseToPeer(peerId, callerSignal) {
+    return await this.runSessionFiniteOperation(
+      async (signal) => await this.requestSynchroniseToPeerWithinSession(peerId, signal),
+      callerSignal
+    );
+  }
+  async requestSynchroniseToPeerWithinSession(peerId, signal) {
     if (!await this.canStartOrdinaryReplication(false)) {
-      return { error: new Error("Replication is not ready") };
+      return p2pReplicationFailed(new Error("Replication is not ready"));
     }
+    if (signal?.aborted) return P2P_REPLICATION_CANCELLED;
     await delay(25);
+    if (signal?.aborted) return P2P_REPLICATION_CANCELLED;
     if (!this.server) throw new Error("Server is not available");
     const conn = this.server.getConnection(peerId);
-    const result = await conn.invokeRemoteFunction("reqSync", [this.server.serverPeerId], 0);
-    return result;
+    try {
+      const result = await conn.invokeRemoteFunction(
+        "reqSync",
+        [this.server.serverPeerId],
+        0,
+        signal
+      );
+      return fromP2PReplicationWireResult(result);
+    } catch (error) {
+      if (signal?.aborted) return P2P_REPLICATION_CANCELLED;
+      throw error;
+    }
   }
   async requestSynchroniseToAllAvailablePeers() {
     await scheduleOnceIfDuplicated("requestSynchroniseToAllAvailablePeers", async () => {
@@ -287,6 +363,7 @@ class TrysteroReplicator {
     });
   }
   dispatchStatus() {
+    if (this.disposed) return;
     this._env.events.emitEvent(EVENT_P2P_REPLICATOR_STATUS, {
       isBroadcasting: this._isBroadcasting,
       replicatingTo: [...this._replicateToPeers],
@@ -347,20 +424,37 @@ class TrysteroReplicator {
     void this.changes.on("complete", closeChanges);
     fireAndForget(async () => await this.notifyProgress());
   }
+  /** Apply automatic broadcast policy without restarting this room. */
+  reconcileAutoBroadcast(enabled) {
+    if (enabled === this._isBroadcasting) return;
+    if (enabled) {
+      this.enableBroadcastChanges();
+    } else {
+      this.disableBroadcastChanges();
+    }
+  }
   get knownAdvertisements() {
     return this.server?.knownAdvertisements ?? [];
   }
   availableReplicationPairs = /* @__PURE__ */ new Set();
-  async sync(remotePeer, showNotice = false) {
-    const from = await this.replicateFrom(remotePeer, showNotice);
-    if (!from || from.error) {
+  async sync(remotePeer, showNotice = false, callerSignal) {
+    return await this.runSessionFiniteOperation(
+      async (signal) => await this.syncWithinSession(remotePeer, showNotice, signal),
+      callerSignal
+    );
+  }
+  async syncWithinSession(remotePeer, showNotice, signal) {
+    const from = await this.replicateFrom(remotePeer, showNotice, false, false, signal);
+    if (isP2PReplicationCancelled(from)) return from;
+    if (from.error) {
       Logger("Error while replicating from the remote", LOG_LEVEL_VERBOSE);
       Logger(from.error, LOG_LEVEL_VERBOSE);
       return from;
     }
+    if (signal?.aborted) return P2P_REPLICATION_CANCELLED;
     const logLevel = showNotice ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO;
     Logger(`P2P Replication has been requested to ${remotePeer}`, logLevel, "p2p-replicator");
-    const res = await this.requestSynchroniseToPeer(remotePeer);
+    const res = await this.requestSynchroniseToPeer(remotePeer, signal);
     if (res.ok) {
       Logger("P2P Replication has been done", logLevel, "p2p-replicator");
     }
@@ -368,29 +462,9 @@ class TrysteroReplicator {
       Logger("Error while syncing from the remote", logLevel, "p2p-replicator");
       Logger(res.error, LOG_LEVEL_VERBOSE);
     }
+    return res;
   }
   _replicateToPeers = /* @__PURE__ */ new Set();
-  // async replicateTo() {
-  //     await this.makeSureOpened();
-  //     const remotePeer = await this.selectPeer();
-  //     if (!remotePeer) {
-  //         Logger("No peer selected", LOG_LEVEL_VERBOSE);
-  //         return;
-  //     }
-  //     Logger(`P2P Replicating to ${remotePeer}`, LOG_LEVEL_INFO);
-  //     try {
-  //         if (this._replicateToPeers.has(remotePeer)) {
-  //             Logger(`Replication to ${remotePeer} is already in progress`, LOG_LEVEL_VERBOSE);
-  //             return;
-  //         }
-  //         this._replicateToPeers.add(remotePeer);
-  //         this.dispatchStatus();
-  //         return await this.requestSynchroniseToPeer(remotePeer);
-  //     } finally {
-  //         this._replicateToPeers.delete(remotePeer);
-  //         this.dispatchStatus();
-  //     }
-  // }
   _replicateFromPeers = /* @__PURE__ */ new Set();
   dispatchReplicationProgress(peerId, info) {
     this.onReplicationProgress(peerId, info);
@@ -446,24 +520,47 @@ class TrysteroReplicator {
       Logger(ex, LOG_LEVEL_VERBOSE);
     });
   }
-  async replicateFrom(remotePeer, showNotice = false, fromStart = false, skipOrdinaryReplicationPolicy = false) {
+  async replicateFrom(remotePeer, showNotice = false, fromStart = false, skipOrdinaryReplicationPolicy = false, callerSignal) {
+    return await this.runSessionFiniteOperation(
+      async (signal) => await this.replicateFromWithinSession(
+        remotePeer,
+        showNotice,
+        fromStart,
+        skipOrdinaryReplicationPolicy,
+        signal
+      ),
+      callerSignal
+    );
+  }
+  async replicateFromWithinSession(remotePeer, showNotice, fromStart, skipOrdinaryReplicationPolicy, signal) {
     if (!skipOrdinaryReplicationPolicy && !await this.canStartOrdinaryReplication(showNotice)) {
-      return { error: new Error("Replication is not ready") };
+      return p2pReplicationFailed(new Error("Replication is not ready"));
     }
+    if (signal?.aborted) return P2P_REPLICATION_CANCELLED;
     const logLevel = showNotice ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO;
     Logger(`P2P Requesting Authentication to ${remotePeer}`, logLevel, "p2p-replicator");
-    if (await this.requestAuthenticate(remotePeer) !== true) {
-      Logger("Peer rejected the connection", LOG_LEVEL_NOTICE, "p2p-replicator");
-      return { error: new Error("Peer rejected the connection") };
+    const authenticated = signal ? await this.requestAuthenticate(remotePeer, signal) : await this.requestAuthenticate(remotePeer);
+    if (authenticated !== true) {
+      if (signal?.aborted) return P2P_REPLICATION_CANCELLED;
+      Logger("Peer rejected the connection", logLevel, "p2p-replicator");
+      return p2pReplicationFailed(new Error("Peer rejected the connection"));
+    }
+    let tweaksMatched;
+    try {
+      tweaksMatched = signal ? await this.checkTweakValues(remotePeer, signal, logLevel) : await this.checkTweakValues(remotePeer, void 0, logLevel);
+    } catch (error) {
+      if (signal?.aborted) return P2P_REPLICATION_CANCELLED;
+      throw error;
     }
-    if (await this.checkTweakValues(remotePeer) !== true) {
-      Logger("Tweak values are not matched", LOG_LEVEL_NOTICE, "p2p-replicator");
-      return { error: new Error("Tweak values are not matched") };
+    if (tweaksMatched !== true) {
+      if (signal?.aborted) return P2P_REPLICATION_CANCELLED;
+      Logger("Tweak values are not matched", logLevel, "p2p-replicator");
+      return p2pReplicationFailed(new Error("Tweak values are not matched"));
     }
     Logger(`P2P Replicating from ${remotePeer}`, logLevel, "p2p-replicator");
     if (this._replicateFromPeers.has(remotePeer)) {
-      Logger(`Replication from ${remotePeer} is already in progress`, LOG_LEVEL_NOTICE, "p2p-replicator");
-      return { error: new Error("Replication from this peer is already in progress") };
+      Logger(`Replication from ${remotePeer} is already in progress`, logLevel, "p2p-replicator");
+      return p2pReplicationFailed(new Error("Replication from this peer is already in progress"));
     }
     this._replicateFromPeers.add(remotePeer);
     this.dispatchStatus();
@@ -472,7 +569,7 @@ class TrysteroReplicator {
         throw new Error("Server is not available");
       }
       const connection = this.server.getConnection(remotePeer);
-      const remoteDB = connection.remoteDB;
+      const remoteDB = connection.getRemoteDB(signal);
       Logger(`P2P replicateFrom preparing remote DB info for ${remotePeer}`, LOG_LEVEL_VERBOSE, "p2p-replicator");
       const remoteDBInfo = await remoteDB.info();
       Logger(
@@ -487,7 +584,7 @@ class TrysteroReplicator {
         "p2p-replicator"
       );
       Logger(`P2P replicateFrom entering replicateShim for ${remotePeer}`, LOG_LEVEL_VERBOSE, "p2p-replicator");
-      await replicateShim(
+      const outcome = await replicateShim(
         this.db,
         remoteDB,
         async (docs, info) => {
@@ -504,22 +601,28 @@ ${info.lastSeq} / ${info.maxSeqInBatch})`,
         },
         {
           live: false,
-          rewind: fromStart
+          rewind: fromStart,
+          signal
           /*, batch_size: batchSize */
         }
       );
       Logger(`P2P replicateFrom replicateShim returned for ${remotePeer}`, LOG_LEVEL_VERBOSE, "p2p-replicator");
       void this.acknowledgeProgress(remotePeer, void 0);
+      if (outcome.status === "cancelled") {
+        Logger(`P2P Replication from ${remotePeer} has been cancelled`, logLevel, "p2p-replicator");
+        return P2P_REPLICATION_CANCELLED;
+      }
       Logger(`P2P Replication from ${remotePeer} has been completed`, logLevel, "p2p-replicator");
     } catch (e) {
+      if (signal?.aborted) return P2P_REPLICATION_CANCELLED;
       Logger("Error while P2P replicating", logLevel, "p2p-replicator");
       Logger(e, LOG_LEVEL_VERBOSE);
-      return { error: e };
+      return p2pReplicationFailed(e);
     } finally {
       this._replicateFromPeers.delete(remotePeer);
       this.dispatchStatus();
     }
-    return { ok: true };
+    return P2P_REPLICATION_COMPLETED;
   }
   notifyProgress(excludePeerId) {
     if (!this._isBroadcasting) return;
@@ -604,14 +707,15 @@ ${info.lastSeq} / ${info.maxSeqInBatch})`,
       return false;
     }
   }
-  async checkTweakValues(peerId) {
+  /** Compare peer settings without exceeding the presentation authority of the initiating call. */
+  async checkTweakValues(peerId, signal, logLevel = LOG_LEVEL_NOTICE) {
     if (!this.server) {
-      Logger("Server is not available", LOG_LEVEL_NOTICE);
+      Logger("Server is not available", logLevel);
       return false;
     }
     const peerPlatform = this.server.knownAdvertisements.find((e) => e.peerId == peerId)?.platform;
     if (peerPlatform == null) {
-      Logger("Peer is not found", LOG_LEVEL_NOTICE);
+      Logger("Peer is not found", logLevel);
       return false;
     }
     if (this.platform === "pseudo-replicator") {
@@ -621,7 +725,8 @@ ${info.lastSeq} / ${info.maxSeqInBatch})`,
       return true;
     }
     const connection = this.server.getConnection(peerId);
-    const tweakValues = await connection.invokeRemoteObjectFunction("getTweakSettings", [this.server.serverPeerId], 5e3);
+    const tweakValues = await connection.invokeRemoteObjectFunction("getTweakSettings", [this.server.serverPeerId], 5e3, signal);
+    if (signal?.aborted) return false;
     const thisTweakValues = await this.getTweakSettings("");
     if (!isObjectDifferent(thisTweakValues, tweakValues)) {
       return true;
@@ -629,43 +734,98 @@ ${info.lastSeq} / ${info.maxSeqInBatch})`,
     if (thisTweakValues.passphrase !== tweakValues.passphrase) {
       Logger(
         "Replication cancelled: Passphrase is not matched\nCannot replicate to a remote database until the problem is resolved.",
-        LOG_LEVEL_NOTICE
+        logLevel
       );
       return false;
     }
     Logger(
       "Some mismatched configuration have been detected... Please check settings for efficient replication.",
-      LOG_LEVEL_NOTICE
+      logLevel
     );
     return true;
   }
-  async replicateFromCommand(showResult = false) {
-    const r = await skipIfDuplicated("replicateFromCommand", async () => {
-      const logLevel = showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO;
-      if (!this._env.settings.P2P_Enabled) {
-        Logger(this.translate("P2P.NotEnabled"), logLevel);
-        return Promise.resolve(false);
+  configuredPeerNames() {
+    return [...new Set(this.currentSettings.P2P_SyncOnReplication.split(",").map((name) => name.trim()))].filter(
+      Boolean
+    );
+  }
+  findAdvertisement(peerName) {
+    return this.knownAdvertisements.find((advertisement) => advertisement.name === peerName);
+  }
+  async waitForConfiguredAdvertisements(peerNames, timeoutMs, signal) {
+    const allPresent = () => peerNames.every((name) => this.findAdvertisement(name) !== void 0);
+    if (allPresent() || timeoutMs <= 0 || signal?.aborted) return;
+    await new Promise((resolve) => {
+      let timeout;
+      let detachAdvertisement = () => void 0;
+      const finish = () => {
+        detachAdvertisement();
+        signal?.removeEventListener("abort", finish);
+        if (timeout !== void 0) compatGlobal.clearTimeout(timeout);
+        resolve();
+      };
+      detachAdvertisement = this._env.events.onEvent(EVENT_ADVERTISEMENT_RECEIVED, () => {
+        if (allPresent()) finish();
+      });
+      signal?.addEventListener("abort", finish, { once: true });
+      timeout = compatGlobal.setTimeout(finish, timeoutMs);
+      if (allPresent() || signal?.aborted) finish();
+    });
+  }
+  configuredTargetResult(name, peerId, result) {
+    if (result.status === "completed") return { name, peerId, status: "completed" };
+    if (result.status === "cancelled") return { name, peerId, status: "cancelled" };
+    return { name, peerId, status: "failed", error: result.error };
+  }
+  /** Synchronise configured peer targets without opening peer-selection UI. */
+  async replicateFromCommand(showResult = false, discoveryTimeoutMs = 5e3, callerSignal) {
+    const logLevel = showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO;
+    if (!this.currentSettings.P2P_Enabled) {
+      Logger(this.translate("P2P.NotEnabled"), logLevel);
+      return { status: "blocked", reason: "no-targets", targets: [] };
+    }
+    const peerNames = this.configuredPeerNames();
+    if (peerNames.length === 0) {
+      Logger(this.translate("P2P.NoAutoSyncPeers"), logLevel);
+      return { status: "blocked", reason: "no-targets", targets: [] };
+    }
+    await this.waitForConfiguredAdvertisements(peerNames, discoveryTimeoutMs, callerSignal);
+    const targets = [];
+    for (const peerName of peerNames) {
+      if (callerSignal?.aborted) {
+        targets.push({ name: peerName, status: "cancelled" });
+        continue;
       }
-      const peers = this._env.settings.P2P_SyncOnReplication.split(",").map((e) => e.trim()).filter((e) => e);
-      if (peers.length == 0) {
-        Logger(this.translate("P2P.NoAutoSyncPeers"), LOG_LEVEL_NOTICE);
-        return Promise.resolve(false);
+      const advertisement = this.findAdvertisement(peerName);
+      if (!advertisement) {
+        Logger(this.translate(`P2P.SeemsOffline`, { name: peerName }), logLevel);
+        targets.push({ name: peerName, status: "missing" });
+        continue;
       }
-      for (const peer of peers) {
-        const peerId = this.knownAdvertisements.find((e) => e.name == peer)?.peerId;
-        if (!peerId) {
-          Logger(this.translate(`P2P.SeemsOffline`, { name: peer }), logLevel);
-        } else {
-          Logger(this.translate(`P2P.SyncStartedWith`, { name: peer }), logLevel);
-          await this.sync(peerId, showResult);
-        }
+      const acceptance = await this.server?.evaluatePeerAcceptance(advertisement.peerId) ?? "unknown";
+      if (acceptance !== "accepted") {
+        targets.push({
+          name: peerName,
+          peerId: advertisement.peerId,
+          status: acceptance === "rejected" ? "rejected" : acceptance === "undecided" ? "undecided" : "missing"
+        });
+        continue;
       }
+      Logger(this.translate(`P2P.SyncStartedWith`, { name: peerName }), logLevel);
+      const result = await this.automationCoordinator.runBaseline(
+        peerName,
+        () => this.sync(advertisement.peerId, showResult, callerSignal)
+      );
+      targets.push(this.configuredTargetResult(peerName, advertisement.peerId, result));
+    }
+    if (targets.every((target) => target.status === "completed")) {
       Logger(this.translate("P2P.SyncCompleted"), logLevel);
-      return Promise.resolve(true);
-    });
-    if (r === null) {
-      Logger(this.translate("P2P.SyncAlreadyRunning"), LOG_LEVEL_NOTICE);
+      return { status: "completed", targets };
+    }
+    if (targets.every((target) => target.status === "cancelled")) {
+      return { status: "cancelled", targets };
     }
+    return { status: "partial", targets };
   }
   disconnectFromServer() {
     const connections = getRelaySockets();

package/dist/replication/trystero/TrysteroReplicatorP2PClient.d.ts

@@ -7,13 +7,16 @@ export declare class TrysteroReplicatorP2PClient {
     _connectedPeerId: string;
     _remoteDB: PouchDBShim<SomeDocument<object>>;
     get remoteDB(): PouchDBShim<SomeDocument<object>>;
+    /** Bind the reverse database RPC calls to one finite-operation signal. */
+    getRemoteDB(signal?: AbortSignal): PouchDBShim<SomeDocument<object>>;
     constructor(server: TrysteroReplicatorP2PServer, connectedPeerId: string);
-    _bindRemoteDB(): PouchDBShim<SomeDocument<object>>;
+    _bindRemoteDB(signal?: AbortSignal): PouchDBShim<SomeDocument<object>>;
+    private getCallOptions;
     _sendRPC(type: string, args: JsonLike[], timeout?: number): Promise<JsonLike>;
     __onResponse(_data: Response): void;
-    bindRemoteFunction<T extends unknown[], U>(type: string, timeout?: number): (...args: T) => Promise<U>;
-    invokeRemoteFunction<T extends unknown[], U>(type: string, args: T, timeout?: number): Promise<U>;
+    bindRemoteFunction<T extends unknown[], U>(type: string, timeout?: number, signal?: AbortSignal): (...args: T) => Promise<U>;
+    invokeRemoteFunction<T extends unknown[], U>(type: string, args: T, timeout?: number, signal?: AbortSignal): Promise<U>;
     bindRemoteObjectFunctions<T extends BindableObject<any>, U extends keyof T>(key: U, timeout?: number): (...args: Parameters<T[U]>) => Promise<Awaited<ReturnType<T[U]>>>;
-    invokeRemoteObjectFunction<T extends BindableObject<any>, U extends NonPrivateMethodKeys<T>>(key: U, args: Parameters<T[U]>, timeout?: number): Promise<Awaited<ReturnType<T[U]>>>;
+    invokeRemoteObjectFunction<T extends BindableObject<any>, U extends NonPrivateMethodKeys<T>>(key: U, args: Parameters<T[U]>, timeout?: number, signal?: AbortSignal): Promise<Awaited<ReturnType<T[U]>>>;
     close(): void;
 }