@vrtmrz/livesync-commonlib 0.1.0-rc.0 → 0.1.0-rc.10

package/dist/platform/node/storage.js

@@ -1,16 +1,40 @@
+import { constants as nodeFsConstants } from "node:fs";
 import * as nodeFsPromises from "node:fs/promises";
 import * as nodePath from "node:path";
 import { validateStoragePath } from "../storagePath.js";
+const NO_FOLLOW = nodeFsConstants.O_NOFOLLOW ?? 0;
+class SymbolicLinkStoragePathError extends Error {
+  constructor(path) {
+    super(`Storage paths must not contain symbolic links: ${path}`);
+    this.name = "SymbolicLinkStoragePathError";
+  }
+}
 class NodeStorageAdapter {
+  rootPath;
   constructor(rootPath) {
-    this.rootPath = rootPath;
+    this.rootPath = nodePath.resolve(rootPath);
   }
-  rootPath;
-  resolvePath(path, allowRoot = true) {
-    return nodePath.join(this.rootPath, validateStoragePath(path, allowRoot));
+  async resolvePath(path, allowRoot = true) {
+    const fullPath = nodePath.join(this.rootPath, validateStoragePath(path, allowRoot));
+    await this.assertNoSymbolicLinks(fullPath);
+    return fullPath;
+  }
+  async assertNoSymbolicLinks(fullPath) {
+    const relativePath = nodePath.relative(this.rootPath, fullPath);
+    let currentPath = this.rootPath;
+    for (const segment of relativePath.split(nodePath.sep).filter(Boolean)) {
+      currentPath = nodePath.join(currentPath, segment);
+      try {
+        const stat = await nodeFsPromises.lstat(currentPath);
+        if (stat.isSymbolicLink()) throw new SymbolicLinkStoragePathError(currentPath);
+      } catch (error) {
+        if (error.code === "ENOENT") return;
+        throw error;
+      }
+    }
   }
   async exists(path) {
-    const fullPath = this.resolvePath(path);
+    const fullPath = await this.resolvePath(path);
     try {
       await nodeFsPromises.access(fullPath);
       return true;
@@ -20,14 +44,15 @@ class NodeStorageAdapter {
   }
   async trystat(path) {
     try {
-      const stat = await nodeFsPromises.stat(this.resolvePath(path));
+      const stat = await nodeFsPromises.stat(await this.resolvePath(path));
       return {
         size: stat.size,
         mtime: Math.floor(stat.mtimeMs),
         ctime: Math.floor(stat.ctimeMs),
         type: stat.isDirectory() ? "folder" : "file"
       };
-    } catch {
+    } catch (error) {
+      if (error instanceof SymbolicLinkStoragePathError) throw error;
       return null;
     }
   }
@@ -35,10 +60,12 @@ class NodeStorageAdapter {
     return await this.trystat(path);
   }
   async mkdir(path) {
-    await nodeFsPromises.mkdir(this.resolvePath(path), { recursive: true });
+    const fullPath = await this.resolvePath(path);
+    await nodeFsPromises.mkdir(fullPath, { recursive: true });
+    await this.assertNoSymbolicLinks(fullPath);
   }
   async remove(path) {
-    const fullPath = this.resolvePath(path, false);
+    const fullPath = await this.resolvePath(path, false);
     const stat = await nodeFsPromises.stat(fullPath);
     if (stat.isDirectory()) {
       await nodeFsPromises.rm(fullPath, { recursive: true, force: true });
@@ -47,33 +74,55 @@ class NodeStorageAdapter {
     }
   }
   async read(path) {
-    return await nodeFsPromises.readFile(this.resolvePath(path, false), "utf-8");
+    const handle = await nodeFsPromises.open(
+      await this.resolvePath(path, false),
+      nodeFsConstants.O_RDONLY | NO_FOLLOW
+    );
+    try {
+      return await handle.readFile("utf-8");
+    } finally {
+      await handle.close();
+    }
   }
   async readBinary(path) {
-    const buffer = await nodeFsPromises.readFile(this.resolvePath(path, false));
-    return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+    const handle = await nodeFsPromises.open(
+      await this.resolvePath(path, false),
+      nodeFsConstants.O_RDONLY | NO_FOLLOW
+    );
+    try {
+      const buffer = await handle.readFile();
+      return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+    } finally {
+      await handle.close();
+    }
   }
   async write(path, data, options) {
-    const fullPath = this.resolvePath(path, false);
+    const fullPath = await this.resolvePath(path, false);
     await nodeFsPromises.mkdir(nodePath.dirname(fullPath), { recursive: true });
-    await nodeFsPromises.writeFile(fullPath, data, "utf-8");
-    await this.applyTimes(fullPath, options);
+    await this.writeFile(fullPath, data, options, false);
   }
   async writeBinary(path, data, options) {
-    const fullPath = this.resolvePath(path, false);
+    const fullPath = await this.resolvePath(path, false);
     await nodeFsPromises.mkdir(nodePath.dirname(fullPath), { recursive: true });
-    await nodeFsPromises.writeFile(fullPath, new Uint8Array(data));
-    await this.applyTimes(fullPath, options);
+    await this.writeFile(fullPath, new Uint8Array(data), options, false);
   }
   async append(path, data, options) {
-    const fullPath = this.resolvePath(path, false);
+    const fullPath = await this.resolvePath(path, false);
     await nodeFsPromises.mkdir(nodePath.dirname(fullPath), { recursive: true });
-    await nodeFsPromises.appendFile(fullPath, data, "utf-8");
-    await this.applyTimes(fullPath, options);
+    await this.writeFile(fullPath, data, options, true);
+  }
+  /** Atomically rename or move an entry without leaving the injected root. */
+  async rename(sourcePath, targetPath) {
+    const fullSourcePath = await this.resolvePath(sourcePath, false);
+    const fullTargetPath = await this.resolvePath(targetPath, false);
+    await nodeFsPromises.mkdir(nodePath.dirname(fullTargetPath), { recursive: true });
+    await this.assertNoSymbolicLinks(fullSourcePath);
+    await this.assertNoSymbolicLinks(fullTargetPath);
+    await nodeFsPromises.rename(fullSourcePath, fullTargetPath);
   }
   async list(basePath) {
     try {
-      const entries = await nodeFsPromises.readdir(this.resolvePath(basePath), { withFileTypes: true });
+      const entries = await nodeFsPromises.readdir(await this.resolvePath(basePath), { withFileTypes: true });
       const files = [];
       const folders = [];
       for (const entry of entries) {
@@ -82,15 +131,27 @@ class NodeStorageAdapter {
         else if (entry.isFile()) files.push(entryPath);
       }
       return { files, folders };
-    } catch {
+    } catch (error) {
+      if (error instanceof SymbolicLinkStoragePathError) throw error;
       return { files: [], folders: [] };
     }
   }
-  async applyTimes(fullPath, options) {
+  async writeFile(fullPath, data, options, append) {
+    await this.assertNoSymbolicLinks(fullPath);
+    const flags = nodeFsConstants.O_WRONLY | nodeFsConstants.O_CREAT | NO_FOLLOW | (append ? nodeFsConstants.O_APPEND : nodeFsConstants.O_TRUNC);
+    const handle = await nodeFsPromises.open(fullPath, flags, 438);
+    try {
+      await handle.writeFile(data, typeof data === "string" ? "utf-8" : void 0);
+      await this.applyTimes(handle, options);
+    } finally {
+      await handle.close();
+    }
+  }
+  async applyTimes(handle, options) {
     if (!options?.mtime && !options?.ctime) return;
     const accessTime = options.mtime ? new Date(options.mtime) : /* @__PURE__ */ new Date();
     const modificationTime = options.mtime ? new Date(options.mtime) : /* @__PURE__ */ new Date();
-    await nodeFsPromises.utimes(fullPath, accessTime, modificationTime);
+    await handle.utimes(accessTime, modificationTime);
   }
 }
 function createNodeStorage({ rootPath }) {

package/dist/platform/standardIo.d.ts

@@ -0,0 +1,19 @@
+/** A chunk written to standard output or standard error. */
+export type StandardIoChunk = string | Uint8Array;
+/**
+ * Host-provided standard input and output for a command-line composition.
+ *
+ * The contract deliberately excludes process lifecycle, logging policy, and
+ * terminal capability detection. Hosts own those concerns separately. None of
+ * the write operations add a newline implicitly.
+ */
+export interface StandardIo {
+    /** Read standard input to completion and decode it as UTF-8 text. */
+    readStdin(): Promise<string>;
+    /** Ask one line-oriented question and return the entered text. */
+    prompt(question: string): Promise<string>;
+    /** Write a text or binary chunk to standard output. */
+    writeStdout(chunk: StandardIoChunk): void;
+    /** Write a text or binary chunk to standard error. */
+    writeStderr(chunk: StandardIoChunk): void;
+}

package/dist/pouchdb/LiveSyncLocalDB.d.ts

@@ -190,6 +190,7 @@ export declare class LiveSyncLocalDB {
     getDBEntry(path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions, dump?: boolean, waitForReady?: boolean, includeDeleted?: boolean): Promise<false | LoadedEntry>;
     getDBEntryFromMeta(meta: LoadedEntry | MetaEntry, dump?: boolean, waitForReady?: boolean): Promise<false | LoadedEntry>;
     deleteDBEntry(path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions): Promise<boolean>;
+    storeDeletionAtRevision(path: FilePathWithPrefix | FilePath, baseRevision: string): Promise<false | PouchDB.Core.Response>;
     putDBEntry(note: SavingEntry, onlyChunks?: boolean, conflictBaseRev?: string): Promise<false | PouchDB.Core.Response>;
     getConflictedDoc(path: FilePathWithPrefix, rev: string): Promise<false | diff_result_leaf>;
     tryAutoMerge(path: FilePathWithPrefix, enableMarkdownAutoMerge: boolean): AutoMergeResult;

package/dist/pouchdb/LiveSyncLocalDB.js

@@ -364,6 +364,9 @@ class LiveSyncLocalDB {
   async deleteDBEntry(path, opt) {
     return await this.managers.entryManager.deleteDBEntry(path, opt);
   }
+  async storeDeletionAtRevision(path, baseRevision) {
+    return await this.managers.entryManager.storeDeletionAtRevision(path, baseRevision);
+  }
   async putDBEntry(note, onlyChunks, conflictBaseRev) {
     return await this.managers.entryManager.putDBEntry(note, onlyChunks, conflictBaseRev);
   }

package/dist/remoteConfigurations.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Focused public primitives for storing and selecting multiple remote connection profiles.
+ *
+ * The compatibility fields remain available to existing hosts, but new profile-management code
+ * should use this entry point instead of importing the wider service feature module.
+ */
+export { activateP2PRemoteConfiguration, activateRemoteConfiguration, createRemoteConfigurationId, suggestRemoteConfigurationName, upsertRemoteConfigurationInPlace, } from "./serviceFeatures/remoteConfig.js";
+export type { SerializableRemoteConfigurationType, UpsertRemoteConfigurationOptions, } from "./serviceFeatures/remoteConfig.js";
+export type { RemoteConfiguration } from "./common/models/setting.type.js";

package/dist/remoteConfigurations.js

@@ -0,0 +1,14 @@
+import {
+  activateP2PRemoteConfiguration,
+  activateRemoteConfiguration,
+  createRemoteConfigurationId,
+  suggestRemoteConfigurationName,
+  upsertRemoteConfigurationInPlace
+} from "./serviceFeatures/remoteConfig.js";
+export {
+  activateP2PRemoteConfiguration,
+  activateRemoteConfiguration,
+  createRemoteConfigurationId,
+  suggestRemoteConfigurationName,
+  upsertRemoteConfigurationInPlace
+};

package/dist/replication/LiveSyncAbstractReplicator.d.ts

@@ -1,6 +1,7 @@
 import { type EntryDoc, type DatabaseConnectingStatus, type RemoteDBSettings, type EntryLeaf, type TweakValues, type NodeData } from "../common/types.js";
 import type { RequiredServices } from "../interfaces/ServiceModule.js";
 import type { TranslationParameters } from "../services/base/MessageTranslator.js";
+import type { CommonlibMessageKey } from "../services/base/CommonlibMessages.js";
 export type ReplicationCallback = (e: PouchDB.Core.ExistingDocument<EntryDoc>[]) => Promise<boolean> | boolean;
 export type ReplicationStat = {
     sent: number;
@@ -34,11 +35,10 @@ export declare abstract class LiveSyncAbstractReplicator {
     remoteLockedAndDeviceNotAccepted: boolean;
     tweakSettingsMismatched: boolean;
     preferredTweakValue?: TweakValues;
-    abstract get isChunkSendingSupported(): boolean;
     get database(): import("../pouchdb/LiveSyncLocalDB.js").LiveSyncLocalDB;
     get rawDatabase(): PouchDB.Database<EntryDoc>;
     get currentSettings(): import("../common/types.js").ObsidianLiveSyncSettings;
-    protected translate<TKey extends string>(key: TKey, params?: TranslationParameters): string;
+    protected translate(key: CommonlibMessageKey, params?: TranslationParameters): string;
     sendChunks(setting: RemoteDBSettings, remoteDB: PouchDB.Database<EntryDoc> | undefined, showResult: boolean, fromSeq?: number | string): Promise<boolean>;
     abstract getReplicationPBKDF2Salt(setting: RemoteDBSettings, refresh?: boolean): Promise<Uint8Array<ArrayBuffer>>;
     ensurePBKDF2Salt(setting: RemoteDBSettings, showMessage?: boolean, useCache?: boolean): Promise<boolean>;
@@ -49,7 +49,7 @@ export declare abstract class LiveSyncAbstractReplicator {
     abstract openReplication(setting: RemoteDBSettings, keepAlive: boolean, showResult: boolean, ignoreCleanLock: boolean): Promise<void | boolean>;
     updateInfo: () => void;
     abstract tryConnectRemote(setting: RemoteDBSettings, showResult?: boolean): Promise<boolean>;
-    abstract replicateAllToServer(setting: RemoteDBSettings, showingNotice?: boolean, sendChunksInBulkDisabled?: boolean): Promise<boolean>;
+    abstract replicateAllToServer(setting: RemoteDBSettings, showingNotice?: boolean): Promise<boolean>;
     abstract replicateAllFromServer(setting: RemoteDBSettings, showingNotice?: boolean): Promise<boolean>;
     abstract closeReplication(): void;
     abstract tryResetRemoteDatabase(setting: RemoteDBSettings): Promise<void>;

package/dist/replication/couchdb/LiveSyncReplicator.d.ts

@@ -5,7 +5,6 @@ export interface LiveSyncCouchDBReplicatorEnv extends LiveSyncReplicatorEnv {
     services: ServiceHub;
 }
 export declare class LiveSyncCouchDBReplicator extends LiveSyncAbstractReplicator {
-    get isChunkSendingSupported(): boolean;
     isMobile(): boolean;
     constructor(env: LiveSyncCouchDBReplicatorEnv);
     getInitialSyncParameters(setting: RemoteDBSettings): Promise<SyncParameters>;

package/dist/replication/couchdb/LiveSyncReplicator.js

@@ -85,9 +85,6 @@ async function* genReplication(s, signal) {
   }
 }
 class LiveSyncCouchDBReplicator extends LiveSyncAbstractReplicator {
-  get isChunkSendingSupported() {
-    return true;
-  }
   isMobile() {
     return this.env.services.API.isMobile();
   }

package/dist/replication/journal/LiveSyncJournalReplicator.d.ts

@@ -7,7 +7,6 @@ import { type SimpleStore } from "../../common/utils.js";
 import type { LiveSyncJournalReplicatorEnv } from "./LiveSyncJournalReplicatorEnv.js";
 export declare class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
     env: LiveSyncJournalReplicatorEnv;
-    get isChunkSendingSupported(): boolean;
     get client(): JournalSyncCore;
     get simpleStore(): SimpleStore<CheckPointInfo>;
     _client: JournalSyncCore;

package/dist/replication/journal/LiveSyncJournalReplicator.js

@@ -19,9 +19,6 @@ const currentVersionRange = {
   current: 2
 };
 class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
-  get isChunkSendingSupported() {
-    return false;
-  }
   get client() {
     return this.setupJournalSyncClient();
   }

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

@@ -18,13 +18,15 @@ export interface LiveSyncTrysteroReplicatorEnv extends LiveSyncReplicatorEnv {
 export declare class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicator {
     private _p2pHost?;
     private _replicator?;
+    private _lifecycleOperation;
+    private _shouldBeOpen;
     get openReplicationUI(): (showResult: boolean) => Promise<boolean | void>;
     get rawReplicator(): TrysteroReplicator;
     get rawHost(): P2PHost;
-    get isChunkSendingSupported(): boolean;
     getReplicationPBKDF2Salt(_setting: RemoteDBSettings, _refresh?: boolean): Promise<Uint8Array<ArrayBuffer>>;
     terminateSync(): void;
     private _buildEnv;
+    private _enqueueLifecycleOperation;
     open(): Promise<void>;
     close(): Promise<void>;
     closeReplication(): void;
@@ -36,7 +38,7 @@ export declare class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicat
     onNewPeer(peer: Advertisement): Promise<void>;
     onPeerLeaved(peerId: string): void;
     replicateFromCommand(showResult?: boolean): Promise<void>;
-    replicateFrom(peerId: string, showNotice?: boolean): Promise<{
+    replicateFrom(peerId: string, showNotice?: boolean, skipOrdinaryReplicationPolicy?: boolean): Promise<{
         error: any;
         ok?: undefined;
     } | {
@@ -67,7 +69,7 @@ export declare class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicat
     makeSureOpened(): Promise<void>;
     openReplication(_setting: RemoteDBSettings, _keepAlive: boolean, showResult: boolean, _ignoreCleanLock: boolean): Promise<void | boolean>;
     tryConnectRemote(_setting: RemoteDBSettings, _showResult?: boolean): Promise<boolean>;
-    replicateAllToServer(_setting: RemoteDBSettings, _showingNotice?: boolean, _sendChunksInBulkDisabled?: boolean): Promise<boolean>;
+    replicateAllToServer(_setting: RemoteDBSettings, _showingNotice?: boolean): Promise<boolean>;
     selectPeer(settingPeerName: string, r: TrysteroReplicator, logLevel: LOG_LEVEL): Promise<string | false>;
     tryUntilSuccess<T>(func: () => Promise<T | false>, repeat: number, logLevel: LOG_LEVEL): Promise<T | false>;
     replicateAllFromServer(setting: RemoteDBSettings, showingNotice?: boolean): Promise<boolean>;

package/dist/replication/trystero/LiveSyncTrysteroReplicator.js

@@ -18,6 +18,8 @@ import { delay } from "octagonal-wheels/promises";
 class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicator {
   _p2pHost;
   _replicator;
+  _lifecycleOperation = Promise.resolve();
+  _shouldBeOpen = false;
   get openReplicationUI() {
     return this.env.openReplicationUI;
   }
@@ -27,9 +29,6 @@ class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicator {
   get rawHost() {
     return this._p2pHost;
   }
-  get isChunkSendingSupported() {
-    return false;
-  }
   getReplicationPBKDF2Salt(_setting, _refresh) {
     return Promise.resolve(new Uint8Array(32));
   }
@@ -59,6 +58,7 @@ class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicator {
         return services.API.confirm;
       },
       runFiniteReplicationActivity: (task, options) => services.replicator.runFiniteReplicationActivity(task, options),
+      canStartOrdinaryReplication: (showMessage = false) => services.replication.onCheckReplicationReady(showMessage),
       processReplicatedDocs: async (docs) => {
         const settings = services.setting.currentSettings();
         if (settings.suspendParseReplicationResult) {
@@ -75,36 +75,48 @@ class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicator {
       }
     };
   }
+  _enqueueLifecycleOperation(operation) {
+    const queued = this._lifecycleOperation.catch(() => void 0).then(operation);
+    this._lifecycleOperation = queued.catch(() => void 0);
+    return queued;
+  }
   async open() {
     if (!this.env.services.setting.currentSettings().P2P_Enabled) {
       Logger(this.translate("P2P.NotEnabled"), LOG_LEVEL_NOTICE);
       return;
     }
-    if (this._replicator && this._p2pHost?.isServing) {
-      Logger("P2P replicator is already open.");
-      return;
-    }
-    try {
-      const env = this._buildEnv();
-      const host = new P2PHost(env);
-      const replicator = new TrysteroReplicator(env, host);
-      this._p2pHost = host;
-      this._replicator = replicator;
-      await replicator.open();
-    } catch (e) {
-      Logger(e instanceof Error ? e.message : "Error while opening P2P connection", LOG_LEVEL_NOTICE);
-      Logger(e, LOG_LEVEL_VERBOSE);
-      this._p2pHost = void 0;
-      this._replicator = void 0;
-    }
+    this._shouldBeOpen = true;
+    await this._enqueueLifecycleOperation(async () => {
+      if (!this._shouldBeOpen) return;
+      if (this._replicator && this._p2pHost?.isServing) {
+        Logger("P2P replicator is already open.");
+        return;
+      }
+      try {
+        const env = this._buildEnv();
+        const host = new P2PHost(env);
+        const replicator = new TrysteroReplicator(env, host);
+        this._p2pHost = host;
+        this._replicator = replicator;
+        await replicator.open();
+      } catch (e) {
+        Logger(e instanceof Error ? e.message : "Error while opening P2P connection", LOG_LEVEL_NOTICE);
+        Logger(e, LOG_LEVEL_VERBOSE);
+        this._p2pHost = void 0;
+        this._replicator = void 0;
+      }
+    });
   }
   async close() {
-    if (this._replicator) {
-      this._replicator.disableBroadcastChanges();
-      await this._replicator.close();
-      this._replicator = void 0;
-    }
-    this._p2pHost = void 0;
+    this._shouldBeOpen = false;
+    await this._enqueueLifecycleOperation(async () => {
+      if (this._replicator) {
+        this._replicator.disableBroadcastChanges();
+        await this._replicator.close();
+        this._replicator = void 0;
+      }
+      this._p2pHost = void 0;
+    });
   }
   closeReplication() {
     this._replicator?.disconnectFromServer();
@@ -138,11 +150,11 @@ class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicator {
       { label: "replication" }
     );
   }
-  async replicateFrom(peerId, showNotice = false) {
+  async replicateFrom(peerId, showNotice = false, skipOrdinaryReplicationPolicy = false) {
     const replicator = this._replicator;
     if (!replicator) throw new Error("P2P replicator is not open");
     return await this.env.services.replicator.runFiniteReplicationActivity(
-      () => replicator.replicateFrom(peerId, showNotice),
+      () => skipOrdinaryReplicationPolicy ? replicator.replicateFrom(peerId, showNotice, false, true) : replicator.replicateFrom(peerId, showNotice),
       { label: "replication" }
     );
   }
@@ -200,7 +212,7 @@ class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicator {
   tryConnectRemote(_setting, _showResult) {
     return Promise.resolve(false);
   }
-  replicateAllToServer(_setting, _showingNotice, _sendChunksInBulkDisabled) {
+  replicateAllToServer(_setting, _showingNotice) {
     return Promise.resolve(false);
   }
   async selectPeer(settingPeerName, r, logLevel) {
@@ -303,7 +315,7 @@ class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicator {
       }
       this.env.services.setting.currentSettings().P2P_RebuildFrom = "";
       Logger("Fetching from peer " + peerId + ".", logLevel);
-      const rep = await r.replicateFrom(peerId, showingNotice);
+      const rep = await r.replicateFrom(peerId, showingNotice, false, true);
       if (rep.ok) {
         Logger("P2P Fetching has been succeed from " + peerId + ".", logLevel);
         return true;

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

@@ -2,11 +2,7 @@ import type { NecessaryServices } from "../../interfaces/ServiceModule.js";
 import type { P2PPaneParams } from "./UseP2PReplicatorResult.js";
 export type P2PViewFactory = (leaf: unknown) => unknown;
 /**
- * ServiceFeature: P2P Replicator lifecycle management.
- * Binds a LiveSyncTrysteroReplicator to the host's lifecycle events,
- * following the same middleware style as useOfflineScanner.
- *
- * @param viewTypeAndFactory  Optional [viewType, factory] pair for registering the P2P pane view.
- *                            When provided, also registers commands and ribbon icon via services.API.
+ * @deprecated Compose `useP2PReplicatorFeature` with host-specific commands
+ * and UI instead. This wrapper remains for source compatibility.
  */
 export declare function useP2PReplicator(host: NecessaryServices<"API" | "appLifecycle" | "setting" | "vault" | "database" | "databaseEvents" | "keyValueDB" | "replication" | "config" | "UI" | "replicator" | "remote", never>, viewTypeAndFactory?: [viewType: string, factory: P2PViewFactory]): P2PPaneParams;

package/dist/replication/trystero/P2PReplicatorCore.js

@@ -1,110 +1,34 @@
-import { AutoAccepting, REMOTE_P2P } from "../../common/types.js";
-import { reactiveSource } from "octagonal-wheels/dataobject/reactive";
+import { REMOTE_P2P } from "../../common/types.js";
+import { reactiveSource } from "octagonal-wheels/dataobject/reactive_v2";
 import { EVENT_REQUEST_OPEN_P2P } from "../../events/coreEvents.js";
-import { LiveSyncTrysteroReplicator } from "./LiveSyncTrysteroReplicator.js";
-import { Logger, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "../../common/logger.js";
 import { P2PLogCollector } from "./P2PLogCollector.js";
-import { addP2PEventHandlers } from "./addP2PEventHandlers.js";
-import { compatGlobal } from "../../common/coreEnvFunctions.js";
+import { useP2PReplicatorCommands } from "./useP2PReplicatorCommands.js";
+import { useP2PReplicatorFeature } from "./useP2PReplicatorFeature.js";
 function useP2PReplicator(host, viewTypeAndFactory) {
-  const env = { services: host.services };
-  let replicator = new LiveSyncTrysteroReplicator(env);
-  const activeReplicator = {
-    get instance() {
-      return replicator;
-    }
-  };
+  const activeReplicator = useP2PReplicatorFeature(host);
   const events = host.services.context.events;
-  addP2PEventHandlers(activeReplicator.instance, events);
   const p2pLogCollector = new P2PLogCollector(events);
   const storeP2PStatusLine = reactiveSource("");
   p2pLogCollector.p2pReplicationLine.onChanged((line) => {
     storeP2PStatusLine.value = line.value;
   });
-  host.services.appLifecycle.onResumed.addHandler(() => {
-    const settings = host.services.setting.currentSettings();
-    if (settings.P2P_Enabled && settings.P2P_AutoStart) {
-      compatGlobal.setTimeout(() => void replicator.open(), 100);
-    }
-    return Promise.resolve(true);
-  });
-  host.services.appLifecycle.onUnload.addHandler(async () => {
-    await replicator.close();
-    return true;
-  });
-  host.services.appLifecycle.onSuspending.addHandler(async () => {
-    await replicator.close();
-    return true;
-  });
-  host.services.databaseEvents.onDatabaseInitialisation.addHandler(async () => {
-    await replicator.close();
-    return true;
-  });
-  host.services.setting.suspendExtraSync.addHandler(() => {
-    const s = host.services.setting.currentSettings();
-    if (s.remoteType !== REMOTE_P2P) {
-      s.P2P_Enabled = false;
-    }
-    s.P2P_AutoAccepting = AutoAccepting.NONE;
-    s.P2P_AutoBroadcast = false;
-    s.P2P_AutoStart = false;
-    s.P2P_AutoSyncPeers = "";
-    s.P2P_AutoWatchPeers = "";
-    return Promise.resolve(true);
-  });
-  host.services.replicator.getNewReplicator.addHandler(
-    async (settingOverride = {}) => {
-      const settings = { ...host.services.setting.currentSettings(), ...settingOverride };
-      if (settings.remoteType == REMOTE_P2P) {
-        try {
-          await replicator.close();
-        } catch (e) {
-          Logger(`Error closing existing p2p replicator`);
-          Logger(e, LOG_LEVEL_VERBOSE);
-        }
-        const newReplicator = new LiveSyncTrysteroReplicator({ services: host.services });
-        replicator = newReplicator;
-        return Promise.resolve(replicator);
-      }
-      return void 0;
-    }
-  );
   if (viewTypeAndFactory) {
     const [viewType, factory] = viewTypeAndFactory;
     const openPane = () => host.services.API.showWindow(viewType);
+    useP2PReplicatorCommands(host, activeReplicator);
     host.services.appLifecycle.onInitialise.addHandler(() => {
       host.services.API.registerWindow(viewType, factory);
-      events.onEvent(EVENT_REQUEST_OPEN_P2P, () => {
-        void openPane();
-      });
+      events.onEvent(EVENT_REQUEST_OPEN_P2P, () => void openPane());
       host.services.API.addCommand({
         id: "open-p2p-replicator",
         name: "P2P Sync : Open P2P Replicator",
-        callback: () => {
-          void openPane();
-        }
-      });
-      host.services.API.addCommand({
-        id: "p2p-establish-connection",
-        name: "P2P Sync : Connect to the Signalling Server",
-        checkCallback: (isChecking) => {
-          if (isChecking) return !(replicator.server?.isServing ?? false);
-          void replicator.open();
-        }
-      });
-      host.services.API.addCommand({
-        id: "p2p-close-connection",
-        name: "P2P Sync : Disconnect from the Signalling Server",
-        checkCallback: (isChecking) => {
-          if (isChecking) return replicator.server?.isServing ?? false;
-          Logger("Closing P2P Connection", LOG_LEVEL_NOTICE);
-          void replicator.close();
-        }
+        callback: () => void openPane()
       });
       host.services.API.addCommand({
         id: "replicate-now-by-p2p",
         name: "Replicate now by P2P",
         checkCallback: (isChecking) => {
+          const replicator = activeReplicator.replicator;
           const settings = host.services.setting.currentSettings();
           if (isChecking) {
             if (settings.remoteType == REMOTE_P2P) return false;
@@ -119,7 +43,13 @@ function useP2PReplicator(host, viewTypeAndFactory) {
       return Promise.resolve(true);
     });
   }
-  return { replicator, p2pLogCollector, storeP2PStatusLine };
+  return {
+    get replicator() {
+      return activeReplicator.replicator;
+    },
+    p2pLogCollector,
+    storeP2PStatusLine
+  };
 }
 export {
   useP2PReplicator

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

@@ -64,6 +64,7 @@ export declare class TrysteroReplicator {
     get confirm(): Confirm;
     get translate(): import("../../context.js").MessageTranslator;
     private runFiniteReplicationActivity;
+    private canStartOrdinaryReplication;
     constructor(env: ReplicatorHostEnv, server?: P2PHost);
     close(): Promise<void>;
     open(): Promise<void>;
@@ -123,7 +124,7 @@ export declare class TrysteroReplicator {
     onReplicationProgress(peerId: string, info?: ProgressInfo): boolean;
     onProgressAcknowledged(peerId: string, info?: ProgressInfo): boolean;
     acknowledgeProgress(remotePeerId: string, info?: ProgressInfo): void;
-    replicateFrom(remotePeer: string, showNotice?: boolean, fromStart?: boolean): Promise<{
+    replicateFrom(remotePeer: string, showNotice?: boolean, fromStart?: boolean, skipOrdinaryReplicationPolicy?: boolean): Promise<{
         error: any;
         ok?: undefined;
     } | {