@oneuptime/common 13.0.8 → 14.0.0

package/UI/esbuild-enterprise.js

@@ -0,0 +1,263 @@
+/**
+ * Enterprise Edition resolution for the frontend builds (Dashboard and
+ * AdminDashboard).
+ *
+ * Each of those frontends imports its Enterprise UI through one bare
+ * specifier, from one file (src/Enterprise/Plugins.ts):
+ *
+ *   Dashboard       "@oneuptime/ee-dashboard"        -> ee/Dashboard/Index.tsx
+ *   AdminDashboard  "@oneuptime/ee-admin-dashboard"  -> ee/AdminDashboard/Index.tsx
+ *
+ * This module decides what that specifier means for one build and returns the
+ * esbuild aliases that make it so. The frontends pass the result to
+ * createConfig({ additionalAlias }) - nothing else about the build changes.
+ *
+ * ONEUPTIME_EDITION picks the edition:
+ *
+ *   auto (default)  Enterprise when the ee plugin file is on disk, Community
+ *                   otherwise. A plain checkout builds whatever it contains.
+ *   community       Always the Community stub, even with ee/ present.
+ *   enterprise      The ee plugin, and a hard error when it is missing. The
+ *                   Enterprise image sets this, so a broken COPY of ee/ fails
+ *                   the build instead of quietly shipping the Community UI
+ *                   under an Enterprise tag.
+ *
+ * Where ee/ is looked for, relative to the frontend directory:
+ *
+ *   <frontend>/../../../../ee   the repository: packages/App/FeatureSet/<F>
+ *   <frontend>/../../../ee      the image: /usr/src/app/FeatureSet/<F> -> /usr/src/ee
+ *
+ * ONEUPTIME_EE_DIR replaces both with one directory (fixtures, tests, odd
+ * layouts) - the same variable the server-side loader honours.
+ *
+ * "Found" means the plugin's Index.tsx FILE exists. The alias points at that
+ * file rather than its directory: esbuild resolves a directory alias to a
+ * lowercase index.* and would miss Index.tsx on a case-sensitive filesystem.
+ *
+ * Two more aliases are always returned, so ee code can reach core without
+ * relative paths and without an install of its own:
+ *
+ *   "@oneuptime/dashboard/..." (or "@oneuptime/admin-dashboard/...")
+ *                -> <frontend>/src/...
+ *   "Common/..." -> <frontend>/node_modules/Common/...
+ *
+ * Bundling therefore never depends on ee/node_modules. Both are applied in
+ * the Community build too, so core resolves identically in both editions.
+ *
+ * CommonJS, like esbuild-config.js: the frontends' esbuild.config.js files
+ * are plain node scripts.
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+const EDITION_ENV_VAR = "ONEUPTIME_EDITION";
+const EE_DIR_ENV_VAR = "ONEUPTIME_EE_DIR";
+
+const EDITION_AUTO = "auto";
+const EDITION_COMMUNITY = "community";
+const EDITION_ENTERPRISE = "enterprise";
+
+const VALID_EDITIONS = [EDITION_AUTO, EDITION_COMMUNITY, EDITION_ENTERPRISE];
+
+const PLUGIN_ENTRY_FILENAME = "Index.tsx";
+
+/*
+ * The Community stub, relative to the frontend directory. Every tsconfig and
+ * jest config maps the plugin specifier to this same file.
+ */
+const COMMUNITY_STUB_PATH = path.join(
+  "src",
+  "Enterprise",
+  "CommunityPlugins.ts",
+);
+
+function isFile(filePath) {
+  try {
+    return fs.statSync(filePath).isFile();
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * The edition the environment asks for: "auto", "community" or "enterprise".
+ * Unset or blank means "auto". Anything else is a typo, and a typo must not
+ * silently build the wrong edition, so it throws.
+ * @param {Object} [env] - Environment to read (defaults to process.env)
+ * @returns {string}
+ */
+function readRequestedEdition(env) {
+  const source = env || process.env;
+  const raw = source[EDITION_ENV_VAR];
+
+  if (raw === undefined || raw === null || String(raw).trim() === "") {
+    return EDITION_AUTO;
+  }
+
+  const value = String(raw).trim().toLowerCase();
+
+  if (!VALID_EDITIONS.includes(value)) {
+    throw new Error(
+      `${EDITION_ENV_VAR} must be one of ${VALID_EDITIONS.join(", ")} (got "${raw}").`,
+    );
+  }
+
+  return value;
+}
+
+/**
+ * Every path the plugin entry may live at, in the order they are tried.
+ * @param {string} frontendDir - Absolute path of the frontend package
+ * @param {string} eeSubdir - "Dashboard" or "AdminDashboard"
+ * @param {Object} [env] - Environment to read (defaults to process.env)
+ * @returns {Array<string>}
+ */
+function getEnterpriseCandidates(frontendDir, eeSubdir, env) {
+  const source = env || process.env;
+  const override = source[EE_DIR_ENV_VAR];
+
+  if (override !== undefined && override !== null && String(override).trim()) {
+    return [
+      path.resolve(String(override).trim(), eeSubdir, PLUGIN_ENTRY_FILENAME),
+    ];
+  }
+
+  return [
+    // Repository: packages/App/FeatureSet/<Frontend> -> <repo>/ee
+    path.resolve(
+      frontendDir,
+      "..",
+      "..",
+      "..",
+      "..",
+      "ee",
+      eeSubdir,
+      PLUGIN_ENTRY_FILENAME,
+    ),
+    // Image: /usr/src/app/FeatureSet/<Frontend> -> /usr/src/ee
+    path.resolve(
+      frontendDir,
+      "..",
+      "..",
+      "..",
+      "ee",
+      eeSubdir,
+      PLUGIN_ENTRY_FILENAME,
+    ),
+  ];
+}
+
+function assertNonEmptyString(value, name) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`resolveEnterpriseBuild: "${name}" is required.`);
+  }
+}
+
+/**
+ * Decide the edition for one frontend build.
+ * @param {Object} options
+ * @param {string} options.frontendDir - Absolute path of the frontend package (its esbuild.config.js __dirname)
+ * @param {string} options.pluginSpecifier - e.g. "@oneuptime/ee-dashboard"
+ * @param {string} options.eeSubdir - Directory under ee/, e.g. "Dashboard"
+ * @param {string} options.internalSpecifier - e.g. "@oneuptime/dashboard"; ee code imports <frontend>/src through it
+ * @param {Object} [options.env] - Environment to read (defaults to process.env)
+ * @returns {{ edition: string, requestedEdition: string, pluginEntry: (string|null), communityStub: string, candidates: Array<string>, alias: Object }}
+ */
+function resolveEnterpriseBuild(options) {
+  const {
+    frontendDir,
+    pluginSpecifier,
+    eeSubdir,
+    internalSpecifier,
+    env = process.env,
+  } = options || {};
+
+  assertNonEmptyString(frontendDir, "frontendDir");
+  assertNonEmptyString(pluginSpecifier, "pluginSpecifier");
+  assertNonEmptyString(eeSubdir, "eeSubdir");
+  assertNonEmptyString(internalSpecifier, "internalSpecifier");
+
+  if (!path.isAbsolute(frontendDir)) {
+    throw new Error(
+      `resolveEnterpriseBuild: "frontendDir" must be absolute (got "${frontendDir}").`,
+    );
+  }
+
+  const communityStub = path.join(frontendDir, COMMUNITY_STUB_PATH);
+
+  if (!isFile(communityStub)) {
+    throw new Error(
+      `The Community plugin stub is missing: ${communityStub}. Every frontend that imports ${pluginSpecifier} needs one.`,
+    );
+  }
+
+  const requestedEdition = readRequestedEdition(env);
+  const candidates = getEnterpriseCandidates(frontendDir, eeSubdir, env);
+
+  const pluginEntry =
+    requestedEdition === EDITION_COMMUNITY
+      ? null
+      : candidates.find(isFile) || null;
+
+  if (requestedEdition === EDITION_ENTERPRISE && !pluginEntry) {
+    throw new Error(
+      `${EDITION_ENV_VAR}=${EDITION_ENTERPRISE}, but the Enterprise UI plugin for ${eeSubdir} was not found. Looked for: ${candidates.join(
+        ", ",
+      )}. Copy the ee/ directory into the build, or unset ${EDITION_ENV_VAR} to build the Community Edition.`,
+    );
+  }
+
+  return {
+    edition: pluginEntry ? EDITION_ENTERPRISE : EDITION_COMMUNITY,
+    requestedEdition,
+    pluginEntry,
+    communityStub,
+    candidates,
+    alias: {
+      [pluginSpecifier]: pluginEntry || communityStub,
+      [internalSpecifier]: path.join(frontendDir, "src"),
+      Common: path.join(frontendDir, "node_modules", "Common"),
+    },
+  };
+}
+
+/**
+ * The esbuild aliases for one frontend build - what esbuild.config.js passes
+ * to createConfig({ additionalAlias }). Same options as resolveEnterpriseBuild.
+ * @param {Object} options
+ * @returns {Object}
+ */
+function resolveEnterpriseAliases(options) {
+  return resolveEnterpriseBuild(options).alias;
+}
+
+/**
+ * One line for the build log, so a CI log shows which edition was bundled.
+ * @param {string} serviceName
+ * @param {Object} build - A resolveEnterpriseBuild() result
+ * @returns {string}
+ */
+function describeEnterpriseBuild(serviceName, build) {
+  if (build.edition === EDITION_ENTERPRISE) {
+    return `${serviceName}: building the Enterprise Edition UI from ${build.pluginEntry}`;
+  }
+
+  return `${serviceName}: building the Community Edition UI (${EDITION_ENV_VAR}=${build.requestedEdition})`;
+}
+
+module.exports = {
+  EDITION_ENV_VAR,
+  EE_DIR_ENV_VAR,
+  EDITION_AUTO,
+  EDITION_COMMUNITY,
+  EDITION_ENTERPRISE,
+  VALID_EDITIONS,
+  PLUGIN_ENTRY_FILENAME,
+  COMMUNITY_STUB_PATH,
+  readRequestedEdition,
+  getEnterpriseCandidates,
+  resolveEnterpriseBuild,
+  resolveEnterpriseAliases,
+  describeEnterpriseBuild,
+};

package/Utils/EnterpriseLicense/EnterpriseLicenseUsage.ts

@@ -1,3 +1,4 @@
+import { ENTERPRISE_LICENSE_GRACE_PERIOD_IN_DAYS } from "../../Types/EnterpriseLicense/EnterpriseLicensePeriods";
 import EnterpriseLicenseUserCountSource from "../../Types/EnterpriseLicense/EnterpriseLicenseUserCountSource";
 
 /*
@@ -49,9 +50,13 @@ export default class EnterpriseLicenseUsageUtil {
   /*
    * Expired licenses keep getting a daily "expired" email for this many
    * days after expiry, then go quiet — an abandoned license should not be
-   * emailed forever.
+   * emailed forever. It has to outlast the grace period by a clear margin:
+   * the email that says single sign-on, SCIM provisioning and audit logging
+   * have now stopped is only worth sending after they have, which is when
+   * the grace period ends.
    */
-  public static readonly expiredNotificationCutoffDays: number = 30;
+  public static readonly expiredNotificationCutoffDays: number =
+    ENTERPRISE_LICENSE_GRACE_PERIOD_IN_DAYS + 14;
 
   /*
    * License keys are shown/emailed masked — enough to identify the key

package/Utils/HostAddressUtil.ts

@@ -0,0 +1,94 @@
+import IP from "../Types/IP/IP";
+
+/*
+ * The two things every caller that holds a host string needs to get right
+ * when that host might be an IPv6 literal, in one place.
+ *
+ * Both are pure text problems that only exist for IPv6, which is exactly why
+ * they kept being got wrong one call site at a time:
+ *
+ *   1. BRACKETS ARE URL SYNTAX, NOT PART OF THE ADDRESS. "[2001:db8::1]" is
+ *      how RFC 3986 writes an IPv6 host inside a URL authority, and that is
+ *      the form URL.fromString and Hostname.fromAuthority hand back. Node
+ *      does NOT strip them: net.connect({host: "[::1]"}) and
+ *      https.get({host: "[::1]"}) both go to the resolver and come back
+ *      ENOTFOUND, and `ping [::1]` fails the same way. An IPv4 host never
+ *      carries brackets, so every one of those call sites worked until
+ *      somebody pointed it at IPv6.
+ *
+ *   2. "host:port" IS AMBIGUOUS FOR IPv6, AND NOT IN A WAY THAT LOOKS WRONG.
+ *      "192.0.2.1:179" cannot be mistaken for an address. Appending ":179" to
+ *      "2001:518:2800:9::2" produces "2001:518:2800:9::2:179", which node's
+ *      net.isIP() reports as a PERFECTLY VALID IPv6 address - a different
+ *      host from the one that was meant. So the unbracketed spelling does not
+ *      merely read oddly, it silently renames the target.
+ */
+export default class HostAddressUtil {
+  /*
+   * True when the value is an IPv6 literal, written bare ("2001:db8::1") or
+   * bracketed ("[2001:db8::1]"). Anything else - a DNS name, an IPv4 literal,
+   * an authority with a port - is false.
+   */
+  public static isIPv6(host: string): boolean {
+    const bare: string = HostAddressUtil.stripBrackets(host);
+
+    if (!bare) {
+      return false;
+    }
+
+    return IP.isIP(bare) && new IP(bare).isIPv6();
+  }
+
+  /*
+   * The address to hand to a socket, a resolver or the ping binary: the same
+   * host with any IPv6 URL brackets removed.
+   *
+   * Brackets are only removed when what is inside them really is an IPv6
+   * address. "[not-an-address]" is returned untouched so it fails validation
+   * downstream as the nonsense it is, rather than being quietly laundered
+   * into a bare hostname.
+   */
+  public static stripBrackets(host: string): string {
+    const trimmed: string = (host || "").trim();
+
+    if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) {
+      return trimmed;
+    }
+
+    const inner: string = trimmed.substring(1, trimmed.length - 1);
+
+    if (!inner || !IP.isIP(inner) || !new IP(inner).isIPv6()) {
+      return trimmed;
+    }
+
+    return inner;
+  }
+
+  /*
+   * The authority form: an IPv6 host is bracketed so the ":" before the port
+   * cannot be read as another group of the address. Already-bracketed input
+   * is not bracketed twice.
+   *
+   * A missing/empty port returns the host on its own, bare. That is
+   * deliberate: a port-less destination is stored and pinged as the address
+   * itself, and wrapping it in brackets there would change what is written to
+   * the database and shown to the user for no benefit - the ambiguity this
+   * guards against only exists once a ":port" is appended.
+   */
+  public static formatHostAndPort(data: {
+    host: string;
+    port?: string | number | undefined;
+  }): string {
+    const bare: string = HostAddressUtil.stripBrackets(data.host);
+    const port: string =
+      data.port === undefined || data.port === null ? "" : String(data.port);
+
+    if (!port) {
+      return bare;
+    }
+
+    return HostAddressUtil.isIPv6(bare)
+      ? `[${bare}]:${port}`
+      : `${bare}:${port}`;
+  }
+}

package/Utils/Monitor/MonitorDestinationUtil.ts

@@ -0,0 +1,157 @@
+import Hostname from "../../Types/API/Hostname";
+import URL from "../../Types/API/URL";
+import Exception from "../../Types/Exception/Exception";
+import IP from "../../Types/IP/IP";
+import MonitorType from "../../Types/Monitor/MonitorType";
+import HostAddressUtil from "../HostAddressUtil";
+
+export interface ParsedMonitorDestination {
+  destination: IP | URL | Hostname | undefined;
+  // Null when the value parsed. A string is the message to show the operator.
+  error: string | null;
+}
+
+/*
+ * Turns what somebody typed (or, far more often, PASTED) into the monitor
+ * destination for a monitor type, or into the reason it cannot be one.
+ *
+ * Lives here rather than inline in the dashboard form so the parsing is
+ * testable on its own — the form's job is state, not address syntax.
+ *
+ * Two IPv6 shapes have to be handled that IPv4 never needed, and getting
+ * either wrong is SILENT rather than loud:
+ *
+ *   - SURROUNDING WHITESPACE. An address copied out of a looking glass, a
+ *     router config or a terminal usually arrives with a trailing space or a
+ *     newline. IP.isIP deliberately does not trim, so " 2001:db8::1" was not
+ *     an IP; it fell through to Hostname.fromString, which split it on the
+ *     first colon into host "2001" / port 518 — a legal Port, so nothing
+ *     threw, no error appeared, and the monitor saved was pointed at a host
+ *     called "2001". The IPv4 equivalent, "1.1.1.1 ", has no colon and
+ *     Hostname trims, so it always worked. That asymmetry is the whole bug:
+ *     the same paste that works for v4 corrupts v6.
+ *
+ *   - BRACKETS. "[2001:db8::1]" is how an IPv6 host is written inside a URL,
+ *     so it is what people have in front of them. For a Ping/IP/Port
+ *     destination there is no URL, so the brackets are noise and are dropped
+ *     — rather than rejected with "Hostname [2001 is not in valid format".
+ */
+export default class MonitorDestinationUtil {
+  public static parse(data: {
+    value: string;
+    monitorType: MonitorType;
+  }): ParsedMonitorDestination {
+    const value: string = (data.value || "").trim();
+
+    if (!value) {
+      return { destination: undefined, error: "Destination is required" };
+    }
+
+    try {
+      switch (data.monitorType) {
+        case MonitorType.IP:
+          return {
+            destination: IP.fromString(HostAddressUtil.stripBrackets(value)),
+            error: null,
+          };
+
+        case MonitorType.Ping:
+        case MonitorType.Port: {
+          const host: string = HostAddressUtil.stripBrackets(value);
+
+          if (IP.isIP(host)) {
+            return { destination: IP.fromString(host), error: null };
+          }
+
+          /*
+           * A trailing colon is a port that was not typed, and
+           * Hostname.fromAuthority DROPS it — deliberately, because a stored
+           * "host:" should still read back as a host. Here that would be the
+           * same class of bug this whole file exists to stop: "2001:" would
+           * be stored as "2001", which is not what anybody typed. Say so
+           * instead.
+           */
+          if (host.endsWith(":")) {
+            return {
+              destination: undefined,
+              error: `${value} is not a valid hostname or IP address.`,
+            };
+          }
+
+          /*
+           * Not an address, so it is a name — possibly with a ":port", which
+           * is what someone pasting "rs1.example.net:179" means.
+           *
+           * fromAuthority rather than `new Hostname`: the constructor accepts
+           * a whole authority and stores it as the HOST, so the destination
+           * would be a host literally named "rs1.example.net:179" and the
+           * socket would go looking for it in DNS. fromAuthority splits the
+           * port off properly, and — unlike the fromString this used to
+           * call — leaves a bare IPv6 literal alone.
+           */
+          return { destination: Hostname.fromAuthority(host), error: null };
+        }
+
+        case MonitorType.Website:
+        case MonitorType.API:
+        case MonitorType.SSLCertificate:
+          return {
+            destination: URL.fromString(
+              MonitorDestinationUtil.toUrlWithBracketedIpv6Host(value),
+            ),
+            error: null,
+          };
+
+        default:
+          return { destination: undefined, error: null };
+      }
+    } catch (err: unknown) {
+      return {
+        destination: undefined,
+        error:
+          err instanceof Exception
+            ? err.getMessage()
+            : (err as Error)?.message || "Invalid Destination",
+      };
+    }
+  }
+
+  /*
+   * A URL whose host is a BARE IPv6 literal is not a URL: "https://2001:db8::1/"
+   * has to be written "https://[2001:db8::1]/", because otherwise the first
+   * colon reads as the port separator. Node's own URL parser, axios and every
+   * browser reject the bare form, so a Website or API monitor saved with one
+   * failed permanently with an opaque target error.
+   *
+   * Brackets the host when it needs them, and leaves every other URL — every
+   * IPv4 and DNS one — byte for byte alone.
+   */
+  public static toUrlWithBracketedIpv6Host(value: string): string {
+    const trimmed: string = value.trim();
+    const schemeMatch: RegExpMatchArray | null = trimmed.match(
+      /^([a-zA-Z][a-zA-Z0-9+.-]*:\/\/)(.*)$/,
+    );
+
+    const scheme: string = schemeMatch ? (schemeMatch[1] as string) : "";
+    const rest: string = schemeMatch ? (schemeMatch[2] as string) : trimmed;
+
+    // The authority ends at the first "/", "?" or "#".
+    const authorityEnd: number = rest.search(/[/?#]/);
+    const authority: string =
+      authorityEnd === -1 ? rest : rest.substring(0, authorityEnd);
+    const remainder: string =
+      authorityEnd === -1 ? "" : rest.substring(authorityEnd);
+
+    // Userinfo is not a host; everything after the last "@" is.
+    const atIndex: number = authority.lastIndexOf("@");
+    const userInfo: string =
+      atIndex === -1 ? "" : authority.substring(0, atIndex + 1);
+    const host: string = authority.substring(atIndex + 1);
+
+    if (!HostAddressUtil.isIPv6(host) || host.startsWith("[")) {
+      return trimmed;
+    }
+
+    return `${scheme}${userInfo}[${host}]${remainder}`;
+  }
+}