@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/services/base/SettingService.js

@@ -0,0 +1,543 @@
+import {
+  ChunkAlgorithmNames,
+  DEFAULT_SETTINGS,
+  LOG_LEVEL_NOTICE,
+  LOG_LEVEL_URGENT,
+  LOG_LEVEL_VERBOSE,
+  SALT_OF_PASSPHRASE,
+  SETTING_KEY_P2P_DEVICE_NAME
+} from "../../common/types.js";
+import { handlers } from "../lib/HandlerUtils.js";
+import { ServiceBase } from "./ServiceBase.js";
+import { createInstanceLogFunction } from "../lib/logUtils.js";
+import { isCloudantURI } from "../../pouchdb/utils_couchdb.js";
+import { decryptString, encryptString } from "../../encryption/stringEncryption.js";
+import { setLang } from "../../common/i18n.js";
+import {
+  activateP2PRemoteConfiguration,
+  activateRemoteConfiguration,
+  migrateLegacyRemoteConfigurationsInPlace,
+  migrateP2PActiveRemoteConfigurationIdInPlace
+} from "../../serviceFeatures/remoteConfig.js";
+import { ConnectionStringParser } from "../../common/ConnectionString.js";
+class SettingService extends ServiceBase {
+  deviceAndVaultName = "";
+  APIService;
+  _settings;
+  get settings() {
+    return this._settings;
+  }
+  set settings(value) {
+    this._settings = value;
+  }
+  _lastPersistedSettings;
+  _log;
+  constructor(context, dependencies) {
+    super(context);
+    this.APIService = dependencies.APIService;
+    this._log = createInstanceLogFunction("SettingService", this.APIService);
+  }
+  /**
+   * Adjust the given settings, e.g., migrate old settings to new format.
+   * @param settings The settings to adjust.
+   */
+  adjustSettings(settings) {
+    if (migrateLegacyRemoteConfigurationsInPlace(settings, (message) => {
+      this._log(message, LOG_LEVEL_NOTICE);
+    })) {
+      this._log(
+        "Legacy remote configuration has been migrated to the remote configuration list.",
+        LOG_LEVEL_NOTICE
+      );
+    }
+    settings.disableRequestURI = true;
+    settings.gcDelay = 0;
+    settings.useHistory = true;
+    if ("workingEncrypt" in settings) delete settings.workingEncrypt;
+    if ("workingPassphrase" in settings) delete settings.workingPassphrase;
+    if (settings.chunkSplitterVersion == "") {
+      if (settings.enableChunkSplitterV2) {
+        if (settings.useSegmenter) {
+          settings.chunkSplitterVersion = "v2-segmenter";
+        } else {
+          settings.chunkSplitterVersion = "v2";
+        }
+      } else {
+        settings.chunkSplitterVersion = "";
+      }
+    } else if (!(settings.chunkSplitterVersion in ChunkAlgorithmNames)) {
+      settings.chunkSplitterVersion = "";
+    }
+    return Promise.resolve(settings);
+  }
+  /**
+   * Get the unique name for identify the device.
+   */
+  getDeviceAndVaultName() {
+    return this.deviceAndVaultName;
+  }
+  /**
+   * Set the unique name for identify the device.
+   * @param name The unique name to set.
+   */
+  setDeviceAndVaultName(name) {
+    this.deviceAndVaultName = name;
+  }
+  /**
+   * Save the current device and vault name to settings, aside from the main settings.
+   */
+  saveDeviceAndVaultName() {
+    const lsKey = "obsidian-live-sync-vaultanddevicename-" + this.APIService.getSystemVaultName() + this.additionalSuffixOfDatabaseName();
+    this.setItem(lsKey, this.deviceAndVaultName);
+  }
+  additionalSuffixOfDatabaseName() {
+    const suffix = this.settings?.additionalSuffixOfDatabaseName;
+    if (typeof suffix === "undefined") {
+      this._log("too early to get additionalSuffixOfDatabaseName, returning empty string");
+      return "";
+    }
+    return `-${suffix}`;
+  }
+  getKey(key) {
+    const keyMain = this.APIService.getSystemVaultName();
+    const addSuffix = this.additionalSuffixOfDatabaseName();
+    return `${keyMain}${addSuffix}-${key}`;
+  }
+  setSmallConfig(key, value) {
+    const dbKey = this.getKey(key);
+    this.setItem(dbKey, value);
+  }
+  getSmallConfig(key) {
+    const dbKey = this.getKey(key);
+    return this.getItem(dbKey);
+  }
+  deleteSmallConfig(key) {
+    const dbKey = this.getKey(key);
+    this.deleteItem(dbKey);
+  }
+  /**
+   * Save the current settings to storage.
+   */
+  async saveSettingData() {
+    this.saveDeviceAndVaultName();
+    const previousSettings = this._lastPersistedSettings ?? this.cloneSettings(this.settings);
+    const settings = {
+      ...this.settings,
+      remoteConfigurations: Object.fromEntries(
+        Object.entries(this.settings.remoteConfigurations || {}).map(([id, config]) => [id, { ...config }])
+      )
+    };
+    const hookResults = await this.onBeforeSaveSettingData(settings, previousSettings);
+    for (const patch of hookResults) {
+      if (patch instanceof Error || !patch) continue;
+      Object.assign(settings, patch);
+      Object.assign(this.settings, patch);
+    }
+    settings.deviceAndVaultName = "";
+    if (settings.P2P_DevicePeerName && settings.P2P_DevicePeerName.trim() !== "") {
+      this._log("Saving device peer name to small config");
+      this.setSmallConfig(SETTING_KEY_P2P_DEVICE_NAME, settings.P2P_DevicePeerName.trim());
+      settings.P2P_DevicePeerName = "";
+    }
+    if (this.usedPassphrase == "" && !await this.getPassphrase(settings)) {
+      this._log("Failed to retrieve passphrase. data.json contains unencrypted items!", LOG_LEVEL_NOTICE);
+    } else {
+      if (settings.couchDB_PASSWORD != "" || settings.couchDB_URI != "" || settings.couchDB_USER != "" || settings.couchDB_DBNAME) {
+        const connectionSetting = {
+          couchDB_DBNAME: settings.couchDB_DBNAME,
+          couchDB_PASSWORD: settings.couchDB_PASSWORD,
+          couchDB_URI: settings.couchDB_URI,
+          couchDB_USER: settings.couchDB_USER,
+          accessKey: settings.accessKey,
+          bucket: settings.bucket,
+          endpoint: settings.endpoint,
+          region: settings.region,
+          secretKey: settings.secretKey,
+          useCustomRequestHandler: settings.useCustomRequestHandler,
+          bucketCustomHeaders: settings.bucketCustomHeaders,
+          couchDB_CustomHeaders: settings.couchDB_CustomHeaders,
+          useJWT: settings.useJWT,
+          jwtKey: settings.jwtKey,
+          jwtAlgorithm: settings.jwtAlgorithm,
+          jwtKid: settings.jwtKid,
+          jwtExpDuration: settings.jwtExpDuration,
+          jwtSub: settings.jwtSub,
+          useRequestAPI: settings.useRequestAPI,
+          bucketPrefix: settings.bucketPrefix,
+          forcePathStyle: settings.forcePathStyle
+        };
+        settings.encryptedCouchDBConnection = await this.encryptConfigurationItem(
+          JSON.stringify(connectionSetting),
+          settings
+        );
+        settings.couchDB_PASSWORD = "";
+        settings.couchDB_DBNAME = "";
+        settings.couchDB_URI = "";
+        settings.couchDB_USER = "";
+        settings.accessKey = "";
+        settings.bucket = "";
+        settings.region = "";
+        settings.secretKey = "";
+        settings.endpoint = "";
+      }
+      if (settings.encrypt && settings.passphrase != "") {
+        settings.encryptedPassphrase = await this.encryptConfigurationItem(settings.passphrase, settings);
+        settings.passphrase = "";
+      }
+      await this.encryptRemoteConfigurationUris(settings);
+    }
+    await this.saveData(settings);
+    this._lastPersistedSettings = this.cloneSettings(this.settings);
+    void this.onSettingSaved(settings);
+  }
+  async encryptRemoteConfigurationUris(settings) {
+    const configs = settings.remoteConfigurations || {};
+    for (const [id, config] of Object.entries(configs)) {
+      if (config.isEncrypted || config.uri.trim() === "") {
+        continue;
+      }
+      const encryptedURI = await this.encryptConfigurationItem(config.uri, settings);
+      if (encryptedURI === "") {
+        this._log(
+          `Failed to encrypt remote configuration '${id}'. This entry will be saved in plain text.`,
+          LOG_LEVEL_URGENT
+        );
+        continue;
+      }
+      configs[id] = {
+        ...config,
+        uri: encryptedURI,
+        isEncrypted: true
+      };
+    }
+  }
+  async decryptRemoteConfigurationUris(settings, passphrase) {
+    const configs = settings.remoteConfigurations || {};
+    for (const [id, config] of Object.entries(configs)) {
+      if (!config.isEncrypted) {
+        continue;
+      }
+      const decryptedURI = await this.decryptConfigurationItem(config.uri, passphrase);
+      if (decryptedURI === false) {
+        try {
+          ConnectionStringParser.parse(config.uri);
+          configs[id] = {
+            ...config,
+            isEncrypted: false
+          };
+          this._log(
+            `Remote configuration '${id}' had a plain-text URI marked as encrypted. The flag has been repaired.`,
+            LOG_LEVEL_NOTICE
+          );
+          continue;
+        } catch {
+        }
+        this._log(
+          `Failed to decrypt remote configuration '${id}'. Verify passphrase and configuration.`,
+          LOG_LEVEL_URGENT
+        );
+        continue;
+      }
+      configs[id] = {
+        ...config,
+        uri: decryptedURI,
+        isEncrypted: false
+      };
+    }
+  }
+  /**
+   * Event triggered before realising the settings.
+   * Handlers can return false to abort the realisation process.
+   */
+  onBeforeRealiseSetting = handlers().bailFirstFailure("onBeforeRealiseSetting");
+  /**
+   * Event triggered after the settings have been realised.
+   */
+  onSettingRealised = handlers().bailFirstFailure("onSettingRealised");
+  /**
+   * Event triggered to realise the settings.
+   */
+  onRealiseSetting = handlers().bailFirstFailure("onRealiseSetting");
+  /**
+   * Suspend all synchronisation activities and save to the settings.
+   */
+  suspendAllSync = handlers().all("suspendAllSync");
+  /**
+   * Suspend extra synchronisation activities, e.g., hidden files sync.
+   */
+  suspendExtraSync = handlers().all("suspendExtraSync");
+  /**
+   * Suggest enabling optional features to the user.
+   */
+  suggestOptionalFeatures = handlers().all("suggestOptionalFeatures");
+  /**
+   * Enable an optional feature and save to the settings.
+   * It may also raised from `handleSuggestOptionalFeatures` if the user agrees.
+   * @param mode The optional feature to enable.
+   */
+  enableOptionalFeature = handlers().all("enableOptionalFeature");
+  onSettingLoaded = handlers().allParallel("onSettingLoaded");
+  onSettingChanged = handlers().allParallel("onSettingChanged");
+  onSettingSaved = handlers().allParallel("onSettingSaved");
+  onBeforeSaveSettingData = handlers().dispatchParallel("onBeforeSaveSettingData");
+  /**
+   * Get the current settings.
+   */
+  currentSettings() {
+    return this.settings;
+  }
+  updateSettings(updateFn, saveImmediately) {
+    try {
+      const updated = updateFn(this.settings);
+      this.settings = updated;
+    } catch (ex) {
+      this._log("Error in update function: ", LOG_LEVEL_URGENT);
+      this._log(ex, LOG_LEVEL_VERBOSE);
+      return Promise.reject(ex instanceof Error ? ex : new Error(String(ex)));
+    }
+    if (saveImmediately) {
+      return this.saveSettingData();
+    }
+    return Promise.resolve();
+  }
+  async applyExternalSettings(partial, saveImmediately) {
+    try {
+      this.settings = await this.adjustSettings({
+        ...this.settings,
+        ...partial
+      });
+    } catch (ex) {
+      this._log("Error in applying external settings: ", LOG_LEVEL_URGENT);
+      this._log(ex, LOG_LEVEL_VERBOSE);
+      return Promise.reject(ex instanceof Error ? ex : new Error(String(ex)));
+    }
+    if (saveImmediately) {
+      return this.saveSettingData();
+    }
+    return Promise.resolve();
+  }
+  applyPartial(partial, saveImmediately) {
+    try {
+      this.settings = { ...this.settings, ...partial };
+    } catch (ex) {
+      this._log("Error in applying partial settings: ", LOG_LEVEL_URGENT);
+      this._log(ex, LOG_LEVEL_VERBOSE);
+      return Promise.reject(ex instanceof Error ? ex : new Error(String(ex)));
+    }
+    if (saveImmediately) {
+      return this.saveSettingData();
+    }
+    return Promise.resolve();
+  }
+  getPassphrase(settings) {
+    const methods = {
+      "": () => Promise.resolve("*"),
+      LOCALSTORAGE: () => Promise.resolve(this.getItem("ls-setting-passphrase") ?? false),
+      ASK_AT_LAUNCH: () => this.APIService.confirm.askString("Passphrase", "passphrase", "")
+    };
+    const method = settings.configPassphraseStore;
+    const methodFunc = method in methods ? methods[method] : methods[""];
+    return methodFunc();
+  }
+  usedPassphrase = "";
+  /**
+   * Clear any used passphrase from memory.
+   */
+  clearUsedPassphrase() {
+    this.usedPassphrase = "";
+  }
+  async decryptConfigurationItem(encrypted, passphrase) {
+    try {
+      const dec = await decryptString(encrypted, passphrase + SALT_OF_PASSPHRASE);
+      if (dec) {
+        this.usedPassphrase = passphrase;
+        return dec;
+      }
+    } catch (ex) {
+      this._log(`Failed to decrypt configuration item`, LOG_LEVEL_NOTICE);
+      this._log(ex, LOG_LEVEL_VERBOSE);
+    }
+    return false;
+  }
+  async encryptConfigurationItem(src, settings) {
+    if (this.usedPassphrase != "") {
+      return await encryptString(src, this.usedPassphrase + SALT_OF_PASSPHRASE);
+    }
+    const passphrase = await this.getPassphrase(settings);
+    if (passphrase === false) {
+      this._log(
+        "Failed to obtain passphrase when saving data.json! Please verify the configuration.",
+        LOG_LEVEL_URGENT
+      );
+      return "";
+    }
+    const dec = await encryptString(src, passphrase + SALT_OF_PASSPHRASE);
+    if (dec) {
+      this.usedPassphrase = passphrase;
+      return dec;
+    }
+    return "";
+  }
+  /**
+   * Decrypt the given settings.
+   * @param settings The settings to decrypt.
+   */
+  async decryptSettings(settings) {
+    const passphrase = await this.getPassphrase(settings);
+    if (passphrase === false) {
+      this._log("No passphrase found for data.json! Verify configuration before syncing.", LOG_LEVEL_URGENT);
+      const hasEncryptedRemoteConfigurations = Object.values(settings.remoteConfigurations || {}).some(
+        (config) => config.isEncrypted
+      );
+      if (hasEncryptedRemoteConfigurations) {
+        this._log(
+          "Encrypted remote configurations found, but passphrase is unavailable. Verify configuration before syncing.",
+          LOG_LEVEL_URGENT
+        );
+      }
+    } else {
+      if (settings.encryptedCouchDBConnection) {
+        const keys = [
+          "couchDB_URI",
+          "couchDB_USER",
+          "couchDB_PASSWORD",
+          "couchDB_DBNAME",
+          "accessKey",
+          "bucket",
+          "endpoint",
+          "region",
+          "secretKey"
+        ];
+        const decrypted = this.tryDecodeJson(
+          await this.decryptConfigurationItem(settings.encryptedCouchDBConnection, passphrase)
+        );
+        if (decrypted) {
+          for (const key of keys) {
+            if (key in decrypted) {
+              settings[key] = decrypted[key];
+            }
+          }
+        } else {
+          this._log(
+            "Failed to decrypt passphrase from data.json! Ensure configuration is correct before syncing with remote.",
+            LOG_LEVEL_URGENT
+          );
+          for (const key of keys) {
+            settings[key] = "";
+          }
+        }
+      }
+      if (settings.encrypt && settings.encryptedPassphrase) {
+        const encrypted = settings.encryptedPassphrase;
+        const decrypted = await this.decryptConfigurationItem(encrypted, passphrase);
+        if (decrypted) {
+          settings.passphrase = decrypted;
+        } else {
+          this._log(
+            "Failed to decrypt passphrase from data.json! Ensure configuration is correct before syncing with remote.",
+            LOG_LEVEL_URGENT
+          );
+          settings.passphrase = "";
+        }
+      }
+      await this.decryptRemoteConfigurationUris(settings, passphrase);
+    }
+    return settings;
+  }
+  async loadSettings() {
+    const settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());
+    const hadRemoteConfigurations = Object.keys(settings.remoteConfigurations ?? {}).length > 0;
+    if (typeof settings.isConfigured == "undefined") {
+      if (JSON.stringify(settings) !== JSON.stringify(DEFAULT_SETTINGS)) {
+        settings.isConfigured = true;
+      } else {
+        const appId = this.APIService.getAppID();
+        settings.additionalSuffixOfDatabaseName = appId;
+        settings.isConfigured = false;
+      }
+    }
+    this.settings = await this.decryptSettings(settings);
+    setLang(this.settings.displayLanguage);
+    await this.adjustSettings(this.settings);
+    const migratedLegacyRemoteConfigurations = !hadRemoteConfigurations && Object.keys(this.settings.remoteConfigurations ?? {}).length > 0;
+    const migratedP2PActiveRemoteConfiguration = migratedLegacyRemoteConfigurations && migrateP2PActiveRemoteConfigurationIdInPlace(this.settings);
+    const activeConfigurationId = this.settings.activeConfigurationId;
+    if (activeConfigurationId && this.settings.remoteConfigurations?.[activeConfigurationId]) {
+      const activated = activateRemoteConfiguration(this.settings, activeConfigurationId);
+      if (!activated) {
+        this._log(
+          `Failed to activate the selected remote configuration: ${activeConfigurationId}`,
+          LOG_LEVEL_NOTICE
+        );
+      } else {
+        this._log(
+          `Active remote configuration '${activeConfigurationId}' has been activated.`,
+          LOG_LEVEL_VERBOSE
+        );
+      }
+    }
+    const p2pActiveConfigurationId = this.settings.P2P_ActiveRemoteConfigurationId;
+    if (p2pActiveConfigurationId && this.settings.remoteConfigurations?.[p2pActiveConfigurationId]) {
+      const activatedP2P = activateP2PRemoteConfiguration(this.settings, p2pActiveConfigurationId);
+      if (!activatedP2P) {
+        this._log(
+          `Failed to activate the selected P2P remote configuration: ${p2pActiveConfigurationId}`,
+          LOG_LEVEL_NOTICE
+        );
+      } else {
+        this._log(
+          `P2P active remote configuration '${p2pActiveConfigurationId}' has been activated.`,
+          LOG_LEVEL_VERBOSE
+        );
+      }
+    }
+    const lsKey = "obsidian-live-sync-vaultanddevicename-" + this.APIService.getSystemVaultName() + this.additionalSuffixOfDatabaseName();
+    if (this.settings.deviceAndVaultName != "") {
+      if (!this.getItem(lsKey)) {
+        this.setDeviceAndVaultName(this.settings.deviceAndVaultName);
+        this.saveDeviceAndVaultName();
+        this.settings.deviceAndVaultName = "";
+      }
+    }
+    if (isCloudantURI(this.settings.couchDB_URI) && this.settings.customChunkSize != 0) {
+      this._log(
+        "Configuration issues detected and automatically resolved. However, unsynchronized data may exist. Consider rebuilding if necessary.",
+        LOG_LEVEL_NOTICE
+      );
+      this.settings.customChunkSize = 0;
+    }
+    this.setDeviceAndVaultName(this.getItem(lsKey) || "");
+    if (this.getDeviceAndVaultName() == "") {
+      if (this.settings.usePluginSync) {
+        this._log("Device name missing. Disabling plug-in sync.", LOG_LEVEL_NOTICE);
+        this.settings.usePluginSync = false;
+      }
+    }
+    if (migratedLegacyRemoteConfigurations || migratedP2PActiveRemoteConfiguration) {
+      await this.saveSettingData();
+    }
+    this._lastPersistedSettings = this.cloneSettings(this.settings);
+    const dispatch = this.settings;
+    void this.onSettingLoaded(dispatch);
+    void this.onSettingChanged(dispatch);
+  }
+  tryDecodeJson(encoded) {
+    try {
+      if (!encoded) return false;
+      return JSON.parse(encoded);
+    } catch {
+      return false;
+    }
+  }
+  cloneSettings(settings) {
+    return {
+      ...settings,
+      remoteConfigurations: Object.fromEntries(
+        Object.entries(settings.remoteConfigurations || {}).map(([id, config]) => [id, { ...config }])
+      )
+    };
+  }
+}
+export {
+  SettingService
+};

package/dist/services/base/TestService.d.ts

@@ -0,0 +1,28 @@
+import type { ITestService } from "./IService.js";
+import { ServiceBase, type ServiceContext } from "./ServiceBase.js";
+/**
+ * The TestService provides methods for adding and handling test results.
+ */
+export declare abstract class TestService<T extends ServiceContext = ServiceContext> extends ServiceBase<T> implements ITestService {
+    /**
+     * Run the test suite to verify the plug-in's functionality.
+     * This is typically used for development and debugging purposes.
+     * It may involve user interaction (means raising resolveByUserInteraction).
+     */
+    readonly test: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<() => Promise<boolean>>;
+    /**
+     * Run the multi-device test suite to verify the plug-in's functionality across multiple devices.
+     * This is typically used for development and debugging purposes.
+     * It may involve user interaction (means raising resolveByUserInteraction).
+     */
+    readonly testMultiDevice: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<() => Promise<boolean>>;
+    /**
+     * Add a test result to the test suite.
+     * @param name The name of the test case.
+     * @param key The key of the test result.
+     * @param result The result of the test (true for success, false for failure).
+     * @param summary A brief summary of the test result.
+     * @param message A detailed message about the test result.
+     */
+    abstract addTestResult(name: string, key: string, result: boolean, summary?: string, message?: string): void;
+}

package/dist/services/base/TestService.js

@@ -0,0 +1,19 @@
+import { handlers } from "../lib/HandlerUtils.js";
+import { ServiceBase } from "./ServiceBase.js";
+class TestService extends ServiceBase {
+  /**
+   * Run the test suite to verify the plug-in's functionality.
+   * This is typically used for development and debugging purposes.
+   * It may involve user interaction (means raising resolveByUserInteraction).
+   */
+  test = handlers().bailFirstFailure("test");
+  /**
+   * Run the multi-device test suite to verify the plug-in's functionality across multiple devices.
+   * This is typically used for development and debugging purposes.
+   * It may involve user interaction (means raising resolveByUserInteraction).
+   */
+  testMultiDevice = handlers().bailFirstFailure("testMultiDevice");
+}
+export {
+  TestService
+};

package/dist/services/base/TweakValueService.d.ts

@@ -0,0 +1,40 @@
+import type { RemoteDBSettings, TweakValues } from "../../common/types.js";
+import type { ITweakValueService } from "./IService.js";
+import { ServiceBase, type ServiceContext } from "./ServiceBase.js";
+/**
+ * The TweakValueService provides methods for managing tweak values and resolving mismatches.
+ */
+export declare abstract class TweakValueService<T extends ServiceContext = ServiceContext> extends ServiceBase<T> implements ITweakValueService {
+    /**
+     * Fetch and trial the remote database settings to determine if they are preferred.
+     * @param trialSetting The remote database settings to connect.
+     */
+    abstract fetchRemotePreferred(trialSetting: RemoteDBSettings): Promise<TweakValues | false>;
+    /**
+     * Check and ask the user to resolve any mismatched tweak values.
+     * @param preferred The preferred tweak values to check against.
+     */
+    abstract checkAndAskResolvingMismatched(preferred: Partial<TweakValues>): Promise<[TweakValues | boolean, boolean]>;
+    /**
+     * Ask the user to resolve any mismatched tweak values.
+     * @param preferredSource The preferred tweak values to resolve against.
+     */
+    abstract askResolvingMismatched(preferredSource: TweakValues): Promise<"OK" | "CHECKAGAIN" | "IGNORE">;
+    /**
+     * Check and ask the user to use the remote configuration.
+     * @param settings The remote database settings to connect.
+     */
+    abstract checkAndAskUseRemoteConfiguration(settings: RemoteDBSettings): Promise<{
+        result: false | TweakValues;
+        requireFetch: boolean;
+    }>;
+    /**
+     * Ask the user to use the remote configuration.
+     * @param trialSetting The remote database settings to connect.
+     * @param preferred The preferred tweak values to use.
+     */
+    abstract askUseRemoteConfiguration(trialSetting: RemoteDBSettings, preferred: TweakValues): Promise<{
+        result: false | TweakValues;
+        requireFetch: boolean;
+    }>;
+}

package/dist/services/base/TweakValueService.js

@@ -0,0 +1,6 @@
+import { ServiceBase } from "./ServiceBase.js";
+class TweakValueService extends ServiceBase {
+}
+export {
+  TweakValueService
+};

package/dist/services/base/UnresolvedErrorManager.d.ts

@@ -0,0 +1,15 @@
+import { type LOG_LEVEL } from "octagonal-wheels/common/logger";
+import type { AppLifecycleService } from "./AppLifecycleService.js";
+import type { LiveSyncEventHub } from "../../hub/hub.js";
+export declare class UnresolvedErrorManager {
+    private readonly events;
+    private _log;
+    private appLifecycleService;
+    private _occurredErrors;
+    showError(msg: string, max_log_level?: LOG_LEVEL): void;
+    clearError(msg: string): void;
+    clearErrors(): void;
+    countErrors(needle: string): number;
+    private _reportUnresolvedMessages;
+    constructor(appLifecycleService: AppLifecycleService, events: LiveSyncEventHub);
+}