@bitblit/ratchet-common 6.0.146-alpha → 6.0.148-alpha

package/src/mail/mailer.ts

@@ -0,0 +1,214 @@
+import { ReadyToSendEmail } from './ready-to-send-email.js';
+import { MailerConfig } from './mailer-config.js';
+import { ResolvedReadyToSendEmail } from './resolved-ready-to-send-email.js';
+import { EmailAttachment } from './email-attachment.js';
+import { MailerLike } from './mailer-like.js';
+import { RequireRatchet } from '../lang/require-ratchet.js';
+import { ErrorRatchet } from '../lang/error-ratchet.js';
+import { Logger } from '../logger/logger.js';
+import { StringRatchet } from '../lang/string-ratchet.js';
+import { Base64Ratchet } from '../lang/base64-ratchet.js';
+import { SendEmailResult } from './send-email-result.js';
+import { ArchiveEmailResult } from './archive-email-result.js';
+
+/**
+ * Generic Mail Sender
+ *
+ * Params:
+ * ses: AWS SES handler, properly configured
+ * defaultSendingAddress:
+ */
+export class Mailer<T, R> implements MailerLike<T, R> {
+  constructor(private config: MailerConfig<T, R>) {
+    RequireRatchet.notNullOrUndefined(config, 'config');
+    RequireRatchet.notNullOrUndefined(config.provider, 'config.provider');
+  }
+
+  public async fillEmailBody(
+    rts: ReadyToSendEmail,
+    context: any,
+    htmlTemplateName: string,
+    txtTemplateName: string = null,
+    layoutName: string = null,
+    partialNames: string[] = null,
+  ): Promise<ReadyToSendEmail> {
+    RequireRatchet.notNullOrUndefined(htmlTemplateName);
+    if (!this.config.templateRenderer) {
+      ErrorRatchet.throwFormattedErr('Cannot use fill body if template renderer not set');
+    }
+    rts.htmlMessage = await this.config.templateRenderer.renderTemplate(htmlTemplateName, context, layoutName, partialNames);
+    rts.txtMessage = txtTemplateName ? await this.config.templateRenderer.renderTemplate(txtTemplateName, context) : null;
+    return rts;
+  }
+
+  public async fillEmailBodyAndSend(
+    rts: ReadyToSendEmail,
+    context: any,
+    htmlTemplateName: string,
+    txtTemplateName: string = null,
+    layoutName: string = null,
+    partialNames: string[] = null,
+  ): Promise<SendEmailResult<T, R>> {
+    const newVal: ReadyToSendEmail = await this.fillEmailBody(rts, context, htmlTemplateName, txtTemplateName, layoutName, partialNames);
+    const rval: SendEmailResult<T, R> = await this.sendEmail(newVal);
+    return rval;
+  }
+
+  public filterEmailsToValid(emails: string[]): string[] {
+    const rval: string[] = (emails || []).filter((e) => {
+      if (!this.config.allowedDestinationEmails || this.config.allowedDestinationEmails.length == 0) {
+        return true;
+      } else {
+        const match: RegExp = this.config.allowedDestinationEmails.find((s) => s.test(e));
+        return !!match;
+      }
+    });
+    return rval;
+  }
+
+  private async archiveEmailIfConfigured(rts: ResolvedReadyToSendEmail, rawSendResult: T): Promise<ArchiveEmailResult<R>> {
+    let rval: ArchiveEmailResult<R> = null;
+    if (!!rts && !!this.config.provider.archiveEmail && !rts.doNotArchive) {
+      Logger.debug('Archiving outbound email to : %j', rts.destinationAddresses);
+      try {
+        const raw: R = await this.config.provider.archiveEmail(rts, rawSendResult);
+        rval = {
+          raw: raw,
+          error: null,
+          meta: {},
+        };
+      } catch (err) {
+        Logger.warn('Failed to archive email %j : %s', rts, err);
+        rval = {
+          raw: null,
+          error: ErrorRatchet.safeStringifyErr(err),
+          meta: {},
+        };
+      }
+    }
+    return rval;
+  }
+
+  public applyLimitsToBodySizesIfAnyInPlace(rts: ResolvedReadyToSendEmail): void {
+    if (this.config.maxMessageBodySizeInBytes) {
+      const txtSize: number = StringRatchet.trimToEmpty(rts.txtMessage).length;
+      const htmlSize: number = StringRatchet.trimToEmpty(rts.htmlMessage).length;
+      const totalSize: number = txtSize + htmlSize;
+      if (totalSize > this.config.maxMessageBodySizeInBytes) {
+        Logger.warn('Max message size is %d but size is %d - converting', this.config.maxMessageBodySizeInBytes, totalSize);
+        rts.attachments = rts.attachments || [];
+        if (StringRatchet.trimToNull(rts.txtMessage)) {
+          const txtAttach: EmailAttachment = {
+            filename: 'original-txt-body.txt',
+            contentType: 'text/plain',
+            base64Data: Base64Ratchet.generateBase64VersionOfString(rts.txtMessage),
+          };
+          rts.attachments.push(txtAttach);
+        }
+        if (StringRatchet.trimToNull(rts.htmlMessage)) {
+          const htmlAttach: EmailAttachment = {
+            filename: 'original-html-body.html',
+            contentType: 'text/html',
+            base64Data: Base64Ratchet.generateBase64VersionOfString(rts.htmlMessage),
+          };
+          rts.attachments.push(htmlAttach);
+        }
+        rts.htmlMessage = null;
+        rts.txtMessage = 'The message was too large and was converted to attachment(s).  Please see attached files for content';
+      }
+    }
+  }
+
+  public applyLimitsToAttachmentSizesIfAnyInPlace(rts: ResolvedReadyToSendEmail): void {
+    if (this.config.maxAttachmentSizeInBase64Bytes) {
+      const filtered: EmailAttachment[] = [];
+      if (rts.attachments) {
+        rts.attachments.forEach((a) => {
+          if (a.base64Data && a.base64Data.length < this.config.maxAttachmentSizeInBase64Bytes) {
+            filtered.push(a);
+          } else {
+            Logger.warn('Removing too-large attachment : %s : %s : %d', a.filename, a.contentType, a.base64Data.length);
+            filtered.push({
+              filename: 'attachment-removed-notice-' + StringRatchet.createRandomHexString(4) + '.txt',
+              contentType: 'text/plain',
+              base64Data: Base64Ratchet.generateBase64VersionOfString(
+                'Attachment ' +
+                  a.filename +
+                  ' of type ' +
+                  a.contentType +
+                  ' was removed since it was ' +
+                  a.base64Data.length +
+                  ' bytes but max allowed is ' +
+                  this.config.maxAttachmentSizeInBase64Bytes,
+              ),
+            });
+          }
+        });
+      }
+      rts.attachments = filtered;
+    }
+  }
+
+  public async sendEmail(inRts: ReadyToSendEmail): Promise<SendEmailResult<T, R>> {
+    RequireRatchet.notNullOrUndefined(inRts, 'RTS must be defined');
+    RequireRatchet.notNullOrUndefined(inRts.destinationAddresses, 'Destination addresses must be defined');
+    let rval: SendEmailResult<T, R> = null;
+
+    const resolved: ResolvedReadyToSendEmail = await this.resolveReadyToSendEmail(inRts);
+    try {
+      const raw: T = await this.config.provider.sendEmail(resolved);
+      const archiveResult: ArchiveEmailResult<R> = await this.archiveEmailIfConfigured(resolved, raw);
+      rval = {
+        request: inRts,
+        resolved: resolved,
+        success: true,
+        rawResult: raw,
+        error: null,
+        meta: {},
+        archiveResults: archiveResult,
+      };
+    } catch (err) {
+      rval = {
+        request: inRts,
+        resolved: resolved,
+        success: false,
+        rawResult: null,
+        error: ErrorRatchet.safeStringifyErr(err),
+        meta: {},
+        archiveResults: null,
+      };
+    }
+
+    return rval;
+  }
+
+  public async resolveReadyToSendEmail(inRts: ReadyToSendEmail): Promise<ResolvedReadyToSendEmail> {
+    RequireRatchet.notNullOrUndefined(inRts, 'RTS must be defined');
+    RequireRatchet.notNullOrUndefined(inRts.destinationAddresses, 'Destination addresses must be defined');
+
+    let toAddresses: string[] = this.filterEmailsToValid(inRts.destinationAddresses);
+    const autoBcc: string[] = inRts.doNotAutoBcc ? [] : this.config.autoBccAddresses || [];
+    const bccAddresses: string[] = (inRts.bccAddresses || []).concat(autoBcc);
+    if (toAddresses.length === 0 && bccAddresses.length > 0) {
+      Logger.debug('Destination emails filtered to none but BCC defined, copying BCC');
+      toAddresses = bccAddresses;
+    }
+
+    const rts: ResolvedReadyToSendEmail = Object.assign({}, inRts);
+    rts.srcDestinationAddresses = inRts.destinationAddresses;
+    rts.srcBccAddresses = inRts.bccAddresses;
+    rts.destinationAddresses = toAddresses;
+    rts.bccAddresses = bccAddresses;
+
+    this.applyLimitsToBodySizesIfAnyInPlace(rts);
+    this.applyLimitsToAttachmentSizesIfAnyInPlace(rts);
+
+    if (rts.destinationAddresses.length === 0) {
+      Logger.info('After cleaning email lists, no destination addresses left - not sending email');
+    }
+
+    rts.fromAddress = rts.fromAddress || this.config.defaultSendingAddress;
+
+    return rts;
+  }
+}

package/src/mail/ready-to-send-email.ts

@@ -0,0 +1,67 @@
+/**
+ * @interface ReadyToSendEmail
+ */
+import { EmailAttachment } from './email-attachment.js';
+
+export interface ReadyToSendEmail {
+  /**
+   *
+   * @type {Array<string>}
+   * @memberof ReadyToSendEmail
+   */
+  destinationAddresses?: string[];
+  /**
+   *
+   * @type {Array<string>}
+   * @memberof ReadyToSendEmail
+   */
+  bccAddresses?: string[];
+  /**
+   *
+   * @type {Array<EmailAttachment>}
+   * @memberof ReadyToSendEmail
+   */
+  attachments?: EmailAttachment[];
+  /**
+   *
+   * @type {string}
+   * @memberof ReadyToSendEmail
+   */
+  fromAddress?: string;
+  /**
+   *
+   * @type {string}
+   * @memberof ReadyToSendEmail
+   */
+  txtMessage?: string;
+  /**
+   *
+   * @type {string}
+   * @memberof ReadyToSendEmail
+   */
+  htmlMessage?: string;
+  /**
+   *
+   * @type {string}
+   * @memberof ReadyToSendEmail
+   */
+  subject?: string;
+  /**
+   *
+   * @type {string}
+   * @memberof ReadyToSendEmail
+   */
+  fromName?: string;
+  /**
+   *
+   * @type {boolean}
+   * @memberof ReadyToSendEmail
+   */
+  doNotAutoBcc?: boolean;
+  /**
+   *
+   * @type {boolean}
+   * @memberof ReadyToSendEmail
+   */
+  doNotArchive?: boolean;
+}

package/src/mail/resolved-ready-to-send-email.ts

@@ -0,0 +1,17 @@
+/**
+ * @interface ResolvedReadyToSendEmail
+ */
+import { ReadyToSendEmail } from './ready-to-send-email.js';
+
+export interface ResolvedReadyToSendEmail extends ReadyToSendEmail {
+  /**
+   * The list of destination addresses before any sending/filtering rules were applied
+   * @type {Array<string>}
+   * @memberof ReadyToSendEmail
+   */
+  srcDestinationAddresses?: string[];
+  /**
+   * The original list of bcc addresses before any auto-bcc were added
+   */
+  srcBccAddresses?: string[];
+}

package/src/mail/send-email-result.ts

@@ -0,0 +1,16 @@
+import { ReadyToSendEmail } from './ready-to-send-email.js';
+import { ResolvedReadyToSendEmail } from './resolved-ready-to-send-email.js';
+import { ArchiveEmailResult } from './archive-email-result.js';
+
+/**
+ * Results of sending an email
+ */
+export interface SendEmailResult<T, R> {
+  request: ReadyToSendEmail;
+  resolved: ResolvedReadyToSendEmail;
+  success: boolean;
+  rawResult: T;
+  error: string;
+  meta: Record<string, any>;
+  archiveResults: ArchiveEmailResult<R>;
+}

package/src/mail/test-mail-sending-provider.ts

@@ -0,0 +1,35 @@
+import { ResolvedReadyToSendEmail } from './resolved-ready-to-send-email.js';
+import { Logger } from '../logger/logger.js';
+import { ErrorRatchet } from '../lang/error-ratchet.js';
+import { MailSendingProvider } from './mail-sending-provider.js';
+
+/**
+ * An implementation of mail sending provider to simplify testing
+ */
+export class TestMailSendingProvider implements MailSendingProvider<string, string> {
+  constructor(public failEmails: string[] = []) {}
+  public async sendEmail(mail: ResolvedReadyToSendEmail): Promise<string> {
+    Logger.info('Called send email : %j', mail);
+    if (this.failEmails) {
+      this.failEmails.forEach((fe) => {
+        if (mail?.destinationAddresses?.includes(fe)) {
+          throw ErrorRatchet.fErr('Forced-fail email address: %s', fe);
+        }
+      });
+    }
+
+    return 'OK';
+  }
+  public async archiveEmail(mail: ResolvedReadyToSendEmail): Promise<string> {
+    Logger.info('Called archive email : %j', mail);
+    if (this.failEmails) {
+      this.failEmails.forEach((fe) => {
+        if (mail?.destinationAddresses?.includes(fe)) {
+          throw ErrorRatchet.fErr('Forced-fail email address: %s', fe);
+        }
+      });
+    }
+
+    return 'OK';
+  }
+}

package/src/network/browser-local-ip-provider.spec.ts

@@ -0,0 +1,23 @@
+import { BrowserLocalIpProvider } from './browser-local-ip-provider.js';
+import { NetworkRatchet } from './network-ratchet.js';
+import { PromiseRatchet } from '../lang/promise-ratchet.js';
+import { describe, expect, test, vi } from 'vitest';
+
+vi.mock('./network-ratchet');
+
+describe('#browserLocalIpProvider', function () {
+  test('should pull a local ip and return it', async () => {
+    const mockStaticFn = vi.fn(() => Promise.resolve('192.168.1.1'));
+
+    NetworkRatchet.findLocalIp = mockStaticFn;
+
+    const up: BrowserLocalIpProvider = new BrowserLocalIpProvider();
+
+    // Just here to handle my old stupid not-understanding promises
+    while (!up.ready()) {
+      await PromiseRatchet.wait(250);
+    }
+
+    expect(up.currentLocalIpAddress()).toEqual('192.168.1.1');
+  });
+});

package/src/network/browser-local-ip-provider.ts

@@ -0,0 +1,26 @@
+import { LocalIpProvider } from './local-ip-provider.js';
+import { NetworkRatchet } from './network-ratchet.js';
+import { Logger } from '../logger/logger.js';
+
+export class BrowserLocalIpProvider implements LocalIpProvider {
+  private currentIp = 'UNSET';
+
+  constructor() {
+    NetworkRatchet.findLocalIp(false)
+      .then((result) => {
+        Logger.info('Setting local IP to %s', result);
+        this.currentIp = result;
+      })
+      .catch((err) => {
+        Logger.warn('Unable to set current IP - leaving as UNSET : %s', err);
+      });
+  }
+
+  ready(): boolean {
+    return this.currentIp !== 'UNSET';
+  }
+
+  currentLocalIpAddress(): string {
+    return this.currentIp;
+  }
+}

package/src/network/fixed-local-ip-provider.ts

@@ -0,0 +1,9 @@
+import { LocalIpProvider } from './local-ip-provider.js';
+
+export class FixedLocalIpProvider implements LocalIpProvider {
+  constructor(private fixed: string) {}
+
+  currentLocalIpAddress(): string {
+    return this.fixed;
+  }
+}

package/src/network/local-ip-provider.ts

@@ -0,0 +1,4 @@
+/** Classes implementing this interface can provide the current local ip address (as a string) * */
+export interface LocalIpProvider {
+  currentLocalIpAddress(): string;
+}

package/src/network/network-ratchet.spec.ts

@@ -0,0 +1,17 @@
+import { NetworkRatchet } from './network-ratchet.js';
+import { ParsedUrl } from '../lang/parsed-url.js';
+import { describe, expect, test } from 'vitest';
+
+describe('#parseUrl', function () {
+  test('should parse the url and return correct values', function () {
+    const result: ParsedUrl = NetworkRatchet.parseUrl('https://example.com:3000/pathname/?search=test#hash');
+
+    expect(result.protocol).toEqual('https:');
+    expect(result.host).toEqual('example.com:3000');
+    expect(result.hostname).toEqual('example.com');
+    expect(result.port).toEqual('3000');
+    expect(result.pathname).toEqual('/pathname/');
+    expect(result.search).toEqual('?search=test');
+    expect(result.hash).toEqual('#hash');
+  });
+});

package/src/network/network-ratchet.ts

@@ -0,0 +1,209 @@
+/*
+    Functions for simplifying some networking tasks
+*/
+
+import { Logger } from '../logger/logger.js';
+import { ParsedUrl } from '../lang/parsed-url.js';
+
+export class NetworkRatchet {
+  private static LOCAL_IP: string = null;
+
+  // Prevent instantiation
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  private constructor() {}
+
+  public static findLocalIp(useCache = true): Promise<string> {
+    Logger.info('Attempting to find local IP (V 2)');
+    if (NetworkRatchet.LOCAL_IP && useCache) {
+      return Promise.resolve(NetworkRatchet.LOCAL_IP);
+    } else {
+      if (typeof window !== 'undefined') {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        return new Promise<string>(function (resolve, reject) {
+          try {
+            // NOTE: window.RTCPeerConnection is "not a constructor" in FF22/23
+            const RTCPeerConnection = window['RTCPeerConnection'] || window['webkitRTCPeerConnection'] || window['mozRTCPeerConnection'];
+
+            if (RTCPeerConnection) {
+              const rtc = new RTCPeerConnection({ iceServers: [] });
+
+              const addrs: any = Object.create(null);
+              addrs['0.0.0.0'] = false;
+
+              // FF [and now Chrome!] needs a channel/stream to proceed
+              rtc.createDataChannel('', { reliable: false });
+              /*
+              CAW - leaving this here for historical reasons, but obviously
+              if (1 ||... is always true, so moving it up
+              if (1 || window['mozRTCPeerConnection']) {
+                // FF [and now Chrome!] needs a channel/stream to proceed
+                rtc.createDataChannel('', { reliable: false });
+              }
+               */
+
+              rtc.onicecandidate = function (evt) {
+                // convert the candidate to SDP so we can run it through our general parser
+                // see https://twitter.com/lancestout/status/525796175425720320 for details
+                if (evt.candidate) {
+                  NetworkRatchet.grepSDP('a=' + evt.candidate.candidate, addrs, resolve);
+                }
+              };
+
+              rtc.createOffer(
+                function (offerDesc) {
+                  NetworkRatchet.grepSDP(offerDesc.sdp, addrs, resolve);
+                  rtc.setLocalDescription(offerDesc);
+                },
+                function (e) {
+                  Logger.warn('Offer failed : %s', e);
+                  resolve(NetworkRatchet.updateLocalIP('FIND_UNSUPPORTED'));
+                },
+              );
+            } else {
+              Logger.warn('IP Address find not supported on this device');
+              resolve(NetworkRatchet.updateLocalIP('FIND_UNSUPPORTED'));
+            }
+          } catch (err) {
+            Logger.warn('Error finding local ip address : %s', err);
+            resolve(NetworkRatchet.updateLocalIP('ERROR'));
+          }
+        });
+      } else {
+        Logger.warn('Window not found, cannot calculate local ip');
+        return Promise.resolve(NetworkRatchet.updateLocalIP('NO_WINDOW'));
+      }
+    }
+  }
+
+  // Break a url into a structure that is similar to what window.location returns
+  // @deprecated CAW 2024-08-09 : Here for backwards compatibility (Node did not used to have URL) - Just use new URL(x) now
+  public static parseUrl(href: string): ParsedUrl {
+    const url: URL = new URL(href);
+    const rval: ParsedUrl =
+      url &&
+      ({
+        href: href,
+        protocol: url.protocol,
+        host: url.host,
+        hostname: url.hostname,
+        port: url.port,
+        pathname: url.pathname,
+        search: url.search,
+        hash: url.hash,
+      } as ParsedUrl);
+    return rval;
+  }
+
+  // Just a helper function to make the build pattern here easier
+  private static updateLocalIP(newIp: string): string {
+    NetworkRatchet.LOCAL_IP = newIp;
+    return NetworkRatchet.LOCAL_IP;
+  }
+
+  private static grepSDP(sdp, addrs, resolve): void {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const hosts: any = [];
+    sdp.split('\r\n').forEach(function (line) {
+      // c.f. http://tools.ietf.org/html/rfc4566#page-39
+      if (~line.indexOf('a=candidate')) {
+        // http://tools.ietf.org/html/rfc4566#section-5.13
+        const parts = line.split(' '), // http://tools.ietf.org/html/rfc5245#section-15.1
+          addr = parts[4],
+          type = parts[7];
+        if (type === 'host') {
+          NetworkRatchet.updateAddressList(addr, addrs, resolve);
+        }
+      } else if (~line.indexOf('c=')) {
+        // http://tools.ietf.org/html/rfc4566#section-5.7
+        const parts = line.split(' '),
+          addr = parts[2];
+        NetworkRatchet.updateAddressList(addr, addrs, resolve);
+      }
+    });
+  }
+
+  private static updateAddressList(newAddr, addrs, resolve): void {
+    if (newAddr in addrs) return;
+    else addrs[newAddr] = true;
+    const displayAddrs = Object.keys(addrs).filter(function (k) {
+      return addrs[k];
+    });
+    if (displayAddrs && displayAddrs.length == 1) {
+      resolve(NetworkRatchet.updateLocalIP(displayAddrs[0]));
+    } else {
+      const multi = displayAddrs.sort().join(',');
+      Logger.warn('Multiple addresses found, returning sorted join : %s', multi);
+      resolve(NetworkRatchet.updateLocalIP(multi));
+    }
+  }
+
+  /*
+    So, this code is actually nicer, but some browsers (e.g., the version of Chromium inside a 6.2.149.7 Brightsign)
+    don't support the promise version, so instead we have the ugly hack above.  Leaving this in here for brighter
+    days in the future.
+
+    https://ourcodeworld.com/articles/read/257/how-to-get-the-client-ip-address-with-javascript-only
+    public static findLocalIp(useCache: boolean = true) : Promise<string>{
+        Logger.info("Attempting to find local IP (V 1)");
+        if (NetworkRatchet.LOCAL_IP && useCache) {
+            return Promise.resolve(NetworkRatchet.LOCAL_IP);
+        }
+        else {
+            if (typeof window !== "undefined") {
+                return new Promise<string>(function(resolve,reject){
+                    //compatibility for firefox and chrome
+                    // NOTE: window.RTCPeerConnection is "not a constructor" in FF22/23
+                    var myPeerConnection = window['RTCPeerConnection'] || window['mozRTCPeerConnection'] || window['webkitRTCPeerConnection'];
+                    var pc = new myPeerConnection({
+                            iceServers: []
+                        }),
+                        noop = function() {},
+                        localIPs = {},
+                        ipRegex = /([0-9]{1,3}(\.[0-9]{1,3}){3}|[a-f0-9]{1,4}(:[a-f0-9]{1,4}){7})/g,
+                        key;
+
+                    //create a bogus data channel
+                    pc.createDataChannel("");
+
+                    // create offer and set local description
+                    pc.createOffer({iceRestart:false}).then(function(sdp) {
+                        sdp.sdp.split('\n').forEach(function(line) {
+                            if (line.indexOf('candidate') < 0) return;
+                            line.match(ipRegex).forEach((ip)=>{
+                                if (!localIPs[ip]){
+                                    NetworkRatchet.LOCAL_IP = ip;
+                                    resolve(ip);
+                                }
+                                localIPs[ip] = true;
+                            });
+                        });
+
+                        pc.setLocalDescription(sdp, noop, noop);
+                    }).catch(function(reason) {
+                        // An error occurred, so handle the failure to connect
+                        Logger.warn("Failed to create peer connection offer : %s",reason);
+                    });
+
+                    //listen for candidate events
+                    pc.onicecandidate = function(ice) {
+                        if (!ice || !ice.candidate || !ice.candidate.candidate || !ice.candidate.candidate.match(ipRegex)) return;
+                        ice.candidate.candidate.match(ipRegex).forEach((ip)=>{
+                            if (!localIPs[ip]){
+                                NetworkRatchet.LOCAL_IP = ip;
+                                resolve(ip);
+                            }
+                            localIPs[ip] = true;
+                        });
+                    };
+                })
+            }
+            else
+            {
+                Logger.warn("Window not found, cannot calculate local ip");
+                NetworkRatchet.LOCAL_IP = "NO_WINDOW";
+                return Promise.resolve(NetworkRatchet.LOCAL_IP);
+            }
+        }
+    }
+    */
+}

package/src/network/remote-file-tracker/backup-result.ts

@@ -0,0 +1,6 @@
+export enum BackupResult {
+  Success = 'Success',
+  Error = 'Error',
+  NotSupported = 'NotSupported',
+  NotRequested = 'NotRequested',
+}

package/src/network/remote-file-tracker/file-transfer-result-type.ts

@@ -0,0 +1,5 @@
+export enum FileTransferResultType {
+  Updated = 'Updated', // File was sent
+  Skipped = 'Skipped', // Update was skipped for some reason (see logs)
+  Error = 'Error',
+}

package/src/network/remote-file-tracker/file-transfer-result.ts

@@ -0,0 +1,9 @@
+import { FileTransferResultType } from './file-transfer-result-type.js';
+import { BackupResult } from './backup-result.js';
+
+export interface FileTransferResult {
+  type: FileTransferResultType;
+  error?: string;
+  bytesTransferred?: number;
+  backupResult: BackupResult;
+}

package/src/network/remote-file-tracker/remote-file-tracker-options.ts

@@ -0,0 +1,6 @@
+import { RemoteFileTrackingProvider } from './remote-file-tracking-provider.js';
+
+export interface RemoteFileTrackerOptions<KeyType> {
+  key: KeyType;
+  provider: RemoteFileTrackingProvider<KeyType>;
+}