@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/replication/trystero/TrysteroReplicator.js

@@ -0,0 +1,683 @@
+import { TweakValuesShouldMatchedTemplate } from "../../common/types.js";
+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 { 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 { 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";
+async function encrypt(data, passphrase) {
+  return await encryptWithEphemeralSalt(data, passphrase, true);
+}
+async function decrypt(encryptedData, passphrase) {
+  return await decryptWithEphemeralSalt(encryptedData, passphrase);
+}
+async function getHashedStringWithCurrentTime(source) {
+  const salt = (~~((/* @__PURE__ */ new Date()).getTime() / 1e3 / 180)).toString(36);
+  const salt2 = await sha1(salt);
+  return await sha1(salt2 + source);
+}
+class TrysteroReplicator {
+  _env;
+  server;
+  replicationStatus() {
+    return {};
+  }
+  get settings() {
+    return this._env.settings;
+  }
+  get db() {
+    return this._env.db;
+  }
+  get deviceName() {
+    return this._env.deviceName;
+  }
+  get platform() {
+    return this._env.platform;
+  }
+  get confirm() {
+    return this._env.confirm;
+  }
+  get translate() {
+    return this._env.translate;
+  }
+  async runFiniteReplicationActivity(task) {
+    if (this._env.runFiniteReplicationActivity) {
+      return await this._env.runFiniteReplicationActivity(task, { label: "replication" });
+    }
+    return await task();
+  }
+  constructor(env, server) {
+    this._env = env;
+    if (server) {
+      this.server = server;
+      return;
+    }
+    try {
+      if (!this.settings.P2P_Enabled) {
+        Logger("P2P is not enabled", LOG_LEVEL_VERBOSE);
+        return;
+      }
+      if (!this.settings.P2P_AppID) {
+        throw new Error("P2P App ID is not provided. We need it to establish the P2P connection");
+      }
+      if (!this.settings.P2P_roomID || !this.settings.P2P_passphrase) {
+        throw new Error(
+          "Room ID and/or P2P Passphrase have not provided. We need them to establish the P2P connection"
+        );
+      }
+      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);
+    } catch (e) {
+      Logger(e instanceof Error ? e.message : "Error while creating TrysteroReplicator", LOG_LEVEL_NOTICE);
+      Logger(e, LOG_LEVEL_VERBOSE);
+      throw e;
+    }
+  }
+  async close() {
+    this.requestStatus();
+    await this.server?.shutdown();
+    this._replicateFromPeers.clear();
+    this._replicateToPeers.clear();
+    this._watchingPeers.clear();
+    this.requestStatus();
+    this.disconnectFromServer();
+  }
+  async open() {
+    this.allowReconnection();
+    await this.server?.start([this.getCommands()]);
+    this.dispatchStatus();
+    if (this.settings.P2P_AutoBroadcast) {
+      this.enableBroadcastChanges();
+    }
+  }
+  async makeSureOpened() {
+    if (!this.server?.isServing) {
+      await this.open();
+    }
+  }
+  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"));
+    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"));
+    return peers;
+  }
+  async onNewPeer(peer) {
+    const peerName = peer.name;
+    if (this.autoSyncPeers.some((e) => e.test(peerName))) {
+      await this.runFiniteReplicationActivity(() => this.sync(peer.peerId));
+    }
+    if (this.autoWatchPeers.some((e) => e.test(peerName))) {
+      this.watchPeer(peer.peerId);
+    }
+  }
+  onPeerLeaved(peerId) {
+    void this.unwatchPeer(peerId);
+  }
+  _onSetup = false;
+  setOnSetup() {
+    this._onSetup = true;
+  }
+  clearOnSetup() {
+    this._onSetup = false;
+  }
+  async getTweakSettings(fromPeerId) {
+    const allSettings = JSON.parse(JSON.stringify(this.settings));
+    for (const key in allSettings) {
+      if (key == "encrypt") {
+        continue;
+      }
+      if (key == "passphrase") {
+        allSettings[key] = await getHashedStringWithCurrentTime(allSettings[key] ?? "");
+        continue;
+      }
+      if (!(key in TweakValuesShouldMatchedTemplate)) {
+        delete allSettings[key];
+      }
+    }
+    return allSettings;
+  }
+  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;
+      },
+      "!reqAuth": async (fromPeerId) => {
+        return await this.server?.isAcceptablePeer(fromPeerId);
+      },
+      getTweakSettings: async (fromPeerId) => {
+        return await this.getTweakSettings(fromPeerId);
+      },
+      onProgress: async (fromPeerId) => {
+        if (this._onSetup) {
+          return { error: 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") };
+        }
+        const passphrase = await skipIfDuplicated(`getAllConfig-${fromPeerId}`, async () => {
+          return await this.confirm.askString(
+            "Passphrase required",
+            this.translate("P2P.AskPassphraseForShare"),
+            "something you only know",
+            true
+          );
+        });
+        const setting = {
+          ...this.settings,
+          configPassphraseStore: "",
+          encryptedCouchDBConnection: "",
+          encryptedPassphrase: "",
+          pluginSyncExtendedSetting: {}
+        };
+        if (!passphrase || passphrase.trim() == "") {
+          Logger(
+            "Passphrase is required to transfer the configuration. The peer cannot be decrypt the config\nIf you repeatedly receive unintended configuration-sharing requests, change the RPC channel immediately. It allows you to leave the connection and disappear, while they are trying brute force attack for the decoy on their local.",
+            LOG_LEVEL_NOTICE
+          );
+          const r = JSON.stringify(
+            Object.fromEntries(
+              Object.entries(setting).map(([key, value]) => {
+                return [key, "******".repeat(Math.ceil(Math.random() * 10) + 2)];
+              })
+            )
+          );
+          const randomString = Math.random().toString(36).substring(7);
+          return encrypt(r, randomString);
+        }
+        return encrypt(JSON.stringify(setting), passphrase.trim());
+      },
+      onProgressAcknowledged: async (fromPeerId, info) => {
+        try {
+          await Promise.resolve(this.onProgressAcknowledged(fromPeerId, info));
+        } catch (e) {
+          Logger("Error while acknowledging the progress", LOG_LEVEL_VERBOSE);
+          Logger(e, LOG_LEVEL_VERBOSE);
+        }
+      },
+      getIsBroadcasting: () => {
+        return Promise.resolve(this._isBroadcasting);
+      },
+      requestBroadcasting: async (peerId) => {
+        if (this._onSetup) {
+          return { error: new Error("The setup is in progress") };
+        }
+        if (this._isBroadcasting) {
+          return true;
+        }
+        if (await skipIfDuplicated(
+          `requested-${peerId}`,
+          async () => await this.confirm.askYesNoDialog(
+            "The remote peer requested to broadcast the changes. Do you want to allow it?",
+            { defaultOption: "No" }
+          )
+        ) === "yes") {
+          this.enableBroadcastChanges();
+        }
+      }
+    };
+  }
+  async requestAuthenticate(peerId) {
+    if (!this.server) return false;
+    try {
+      const connection = this.server.getConnection(peerId);
+      const selfPeerId = this.server.serverPeerId;
+      const r = await connection.invokeRemoteObjectFunction(
+        "!reqAuth",
+        [selfPeerId],
+        2e4
+      );
+      return r;
+    } catch (e) {
+      Logger("Error while requesting authentication", LOG_LEVEL_VERBOSE);
+      Logger(e, LOG_LEVEL_VERBOSE);
+      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) {
+    await delay(25);
+    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;
+  }
+  async requestSynchroniseToAllAvailablePeers() {
+    await scheduleOnceIfDuplicated("requestSynchroniseToAllAvailablePeers", async () => {
+      await delay(25);
+      const replications = [...this.availableReplicationPairs].map((peerId) => {
+        return this.requestSynchroniseToPeer(peerId);
+      });
+      await Promise.all(replications);
+    });
+  }
+  dispatchStatus() {
+    this._env.events.emitEvent(EVENT_P2P_REPLICATOR_STATUS, {
+      isBroadcasting: this._isBroadcasting,
+      replicatingTo: [...this._replicateToPeers],
+      replicatingFrom: [...this._replicateFromPeers],
+      watchingPeers: [...this._watchingPeers]
+    });
+  }
+  requestStatus() {
+    this.dispatchStatus();
+    void this.server?.dispatchConnectionStatus();
+  }
+  changes;
+  _isBroadcasting = false;
+  disableBroadcastChanges() {
+    this.changes?.cancel();
+    this._isBroadcasting = false;
+    this.dispatchStatus();
+  }
+  enableBroadcastChanges() {
+    if (this._isBroadcasting) return;
+    this._isBroadcasting = true;
+    this.dispatchStatus();
+    if (this.changes) {
+      void this.changes.cancel();
+      void this.changes.removeAllListeners();
+    }
+    this.changes = this.db.changes({
+      since: "now",
+      live: true,
+      include_docs: false,
+      selector: {
+        _id: {
+          $gt: "_local/"
+        }
+      }
+    });
+    void this.changes.on("change", async (change) => {
+      this.lastSeq = change.seq;
+      await this.notifyProgress();
+    });
+    const closeChanges = (reason) => {
+      if (reason) {
+        if (reason instanceof Error) {
+          Logger(`Error while broadcasting the changes`, LOG_LEVEL_INFO);
+          Logger(reason, LOG_LEVEL_VERBOSE);
+        } else {
+          Logger(`Broadcasting the changes has been finished`, LOG_LEVEL_INFO);
+          Logger(reason, LOG_LEVEL_VERBOSE);
+        }
+      }
+      void this.changes?.cancel();
+      void this.changes?.removeAllListeners();
+      this.changes = void 0;
+      this._isBroadcasting = false;
+      this.dispatchStatus();
+    };
+    void this.changes.on("error", closeChanges);
+    void this.changes.on("complete", closeChanges);
+    fireAndForget(async () => await this.notifyProgress());
+  }
+  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) {
+      Logger("Error while replicating from the remote", LOG_LEVEL_VERBOSE);
+      Logger(from.error, LOG_LEVEL_VERBOSE);
+      return from;
+    }
+    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);
+    if (res.ok) {
+      Logger("P2P Replication has been done", logLevel, "p2p-replicator");
+    }
+    if (res.error) {
+      Logger("Error while syncing from the remote", logLevel, "p2p-replicator");
+      Logger(res.error, LOG_LEVEL_VERBOSE);
+    }
+  }
+  _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);
+  }
+  onReplicationProgress(peerId, info) {
+    const name = this.server?._knownAdvertisements.get(peerId)?.name || peerId;
+    const stat = {
+      peerId,
+      peerName: name,
+      fetching: {
+        max: 0,
+        current: 0,
+        isActive: false
+      }
+    };
+    if (info) {
+      stat.fetching = {
+        max: info.maxSeqInBatch,
+        current: info.lastSeq,
+        isActive: true
+      };
+    }
+    this._env.events.emitEvent(EVENT_P2P_REPLICATOR_PROGRESS, stat);
+    return true;
+  }
+  onProgressAcknowledged(peerId, info) {
+    const name = this.server?._knownAdvertisements.get(peerId)?.name || peerId;
+    const ack = {
+      peerId,
+      peerName: name,
+      sending: {
+        max: 0,
+        current: 0,
+        isActive: false
+      }
+    };
+    if (info) {
+      ack.sending = {
+        max: info.maxSeqInBatch,
+        current: info.lastSeq,
+        isActive: true
+      };
+    }
+    this._env.events.emitEvent(EVENT_P2P_REPLICATOR_PROGRESS, ack);
+    return true;
+  }
+  // Sending the progress to the remote peer
+  acknowledgeProgress(remotePeerId, info) {
+    if (!this.server) return;
+    const connection = this.server.getConnection(remotePeerId);
+    void connection.invokeRemoteFunction("onProgressAcknowledged", [this.server.serverPeerId, info], 500).catch((ex) => {
+      Logger("Error while acknowledging the progress", LOG_LEVEL_VERBOSE);
+      Logger(ex, LOG_LEVEL_VERBOSE);
+    });
+  }
+  async replicateFrom(remotePeer, showNotice = false, fromStart = false) {
+    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") };
+    }
+    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") };
+    }
+    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") };
+    }
+    this._replicateFromPeers.add(remotePeer);
+    this.dispatchStatus();
+    try {
+      if (!this.server) {
+        throw new Error("Server is not available");
+      }
+      const connection = this.server.getConnection(remotePeer);
+      const remoteDB = connection.remoteDB;
+      Logger(`P2P replicateFrom preparing remote DB info for ${remotePeer}`, LOG_LEVEL_VERBOSE, "p2p-replicator");
+      const remoteDBInfo = await remoteDB.info();
+      Logger(
+        `P2P replicateFrom remote DB info for ${remotePeer}: ${remoteDBInfo.db_name} seq=${remoteDBInfo.update_seq}`,
+        LOG_LEVEL_VERBOSE,
+        "p2p-replicator"
+      );
+      const localDBInfo = await this.db.info();
+      Logger(
+        `P2P replicateFrom local DB info for ${remotePeer}: ${localDBInfo.db_name} seq=${localDBInfo.update_seq}`,
+        LOG_LEVEL_VERBOSE,
+        "p2p-replicator"
+      );
+      Logger(`P2P replicateFrom entering replicateShim for ${remotePeer}`, LOG_LEVEL_VERBOSE, "p2p-replicator");
+      await replicateShim(
+        this.db,
+        remoteDB,
+        async (docs, info) => {
+          await this._env.processReplicatedDocs(docs);
+          void this.dispatchReplicationProgress(remotePeer, info);
+          void this.acknowledgeProgress(remotePeer, info);
+          void this.notifyProgress(remotePeer);
+          Logger(
+            `P2P Replication from ${remotePeer}
+${info.lastSeq} / ${info.maxSeqInBatch})`,
+            logLevel,
+            "p2p-replicator"
+          );
+        },
+        {
+          live: false,
+          rewind: fromStart
+          /*, batch_size: batchSize */
+        }
+      );
+      Logger(`P2P replicateFrom replicateShim returned for ${remotePeer}`, LOG_LEVEL_VERBOSE, "p2p-replicator");
+      void this.acknowledgeProgress(remotePeer, void 0);
+      Logger(`P2P Replication from ${remotePeer} has been completed`, logLevel, "p2p-replicator");
+    } catch (e) {
+      Logger("Error while P2P replicating", logLevel, "p2p-replicator");
+      Logger(e, LOG_LEVEL_VERBOSE);
+      return { error: e };
+    } finally {
+      this._replicateFromPeers.delete(remotePeer);
+      this.dispatchStatus();
+    }
+    return { ok: true };
+  }
+  notifyProgress(excludePeerId) {
+    if (!this._isBroadcasting) return;
+    if (!this.server) return;
+    for (const peer of this.server.knownAdvertisements) {
+      const peerId = peer.peerId;
+      if (peerId === excludePeerId) continue;
+      void serialized(`notifyProgress-${peerId}`, async () => {
+        const isAcceptable = await this.server?.isAcceptablePeer(peerId);
+        if (isAcceptable) {
+          try {
+            const ret = await this.server?.getConnection(peerId).invokeRemoteFunction("onProgress", [this.server?.serverPeerId], 0);
+            return ret;
+          } catch (e) {
+            Logger(`Error while notifying progress to ${peerId}`, LOG_LEVEL_VERBOSE);
+            Logger(e, LOG_LEVEL_VERBOSE);
+          }
+        } else {
+          Logger(`Peer ${peerId} is not acceptable to notify progress`, LOG_LEVEL_VERBOSE);
+        }
+      });
+    }
+    return Promise.resolve();
+  }
+  async requestBroadcastChanges(peerId) {
+    return await this.server?.getConnection(peerId).invokeRemoteFunction("requestBroadcasting", [this.server.serverPeerId], 0);
+  }
+  async getRemoteIsBroadcasting(peerId) {
+    try {
+      return await this.server?.getConnection(peerId).invokeRemoteFunction("getIsBroadcasting", [], 0);
+    } catch (e) {
+      Logger("Error while getting remote is broadcasting", LOG_LEVEL_VERBOSE);
+      Logger(e, LOG_LEVEL_VERBOSE);
+    }
+  }
+  _watchingPeers = /* @__PURE__ */ new Set();
+  watchPeer(peerId) {
+    this._watchingPeers.add(peerId);
+    this.dispatchStatus();
+  }
+  unwatchPeer(peerId) {
+    this._watchingPeers.delete(peerId);
+    this.dispatchStatus();
+  }
+  async onUpdateDatabase(fromPeerId) {
+    if (this._watchingPeers.has(fromPeerId)) {
+      Logger(`Progress notification from ${fromPeerId}`, LOG_LEVEL_VERBOSE);
+      return await serialized(`onProgress-${fromPeerId}`, async () => {
+        return await this.runFiniteReplicationActivity(() => this.replicateFrom(fromPeerId));
+      });
+    }
+    return false;
+  }
+  async getRemoteConfig(peerId) {
+    if (!this.server) {
+      Logger("Server is not available", LOG_LEVEL_NOTICE);
+      return false;
+    }
+    const connection = this.server.getConnection(peerId);
+    const encryptedConfig = await connection.invokeRemoteFunction("getAllConfig", [this.server.serverPeerId], 0);
+    const passphrase = await this.confirm.askString(
+      "Passphrase required",
+      this.translate("P2P.AskPassphraseForDecrypt"),
+      "something you only know",
+      true
+    );
+    if (!passphrase || passphrase.trim() == "") {
+      Logger(
+        "Passphrase is required to decrypt the configuration. The config cannot be decrypted",
+        LOG_LEVEL_NOTICE
+      );
+      return false;
+    }
+    try {
+      const decryptedConfig = JSON.parse(
+        await decrypt(encryptedConfig, passphrase)
+      );
+      return decryptedConfig;
+    } catch (e) {
+      Logger("Error while decrypting the configuration", LOG_LEVEL_NOTICE);
+      Logger(e, LOG_LEVEL_VERBOSE);
+      return false;
+    }
+  }
+  async checkTweakValues(peerId) {
+    if (!this.server) {
+      Logger("Server is not available", LOG_LEVEL_NOTICE);
+      return false;
+    }
+    const peerPlatform = this.server.knownAdvertisements.find((e) => e.peerId == peerId)?.platform;
+    if (peerPlatform == null) {
+      Logger("Peer is not found", LOG_LEVEL_NOTICE);
+      return false;
+    }
+    if (this.platform === "pseudo-replicator") {
+      return true;
+    }
+    if (peerPlatform === "pseudo-replicator") {
+      return true;
+    }
+    const connection = this.server.getConnection(peerId);
+    const tweakValues = await connection.invokeRemoteObjectFunction("getTweakSettings", [this.server.serverPeerId], 5e3);
+    const thisTweakValues = await this.getTweakSettings("");
+    if (!isObjectDifferent(thisTweakValues, tweakValues)) {
+      return true;
+    }
+    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
+      );
+      return false;
+    }
+    Logger(
+      "Some mismatched configuration have been detected... Please check settings for efficient replication.",
+      LOG_LEVEL_NOTICE
+    );
+    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);
+      }
+      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);
+      }
+      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);
+        }
+      }
+      Logger(this.translate("P2P.SyncCompleted"), logLevel);
+      return Promise.resolve(true);
+    });
+    if (r === null) {
+      Logger(this.translate("P2P.SyncAlreadyRunning"), LOG_LEVEL_NOTICE);
+    }
+  }
+  disconnectFromServer() {
+    const connections = getRelaySockets();
+    const sockets = Object.entries(connections);
+    pauseRelayReconnection();
+    sockets.forEach(([, s]) => {
+      s.close();
+      s.onclose = () => {
+        void this.server?.dispatchConnectionStatus();
+      };
+    });
+    void this.pauseServe();
+  }
+  async pauseServe() {
+    await this.server?.close();
+    await this.server?.dispatchConnectionStatus();
+  }
+  allowReconnection() {
+    resumeRelayReconnection();
+  }
+}
+export {
+  TrysteroReplicator
+};

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

@@ -0,0 +1,19 @@
+import type { PouchDBShim, SomeDocument } from "../../pouchdb/ReplicatorShim.js";
+import type { TrysteroReplicatorP2PServer } from "./TrysteroReplicatorP2PServer.js";
+import { type BindableObject, type NonPrivateMethodKeys, type Response } from "./types.js";
+import type { JsonLike } from "../../rpc/index.js";
+export declare class TrysteroReplicatorP2PClient {
+    _server: TrysteroReplicatorP2PServer;
+    _connectedPeerId: string;
+    _remoteDB: PouchDBShim<SomeDocument<object>>;
+    get remoteDB(): PouchDBShim<SomeDocument<object>>;
+    constructor(server: TrysteroReplicatorP2PServer, connectedPeerId: string);
+    _bindRemoteDB(): PouchDBShim<SomeDocument<object>>;
+    _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>;
+    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]>>>;
+    close(): void;
+}