@oneuptime/common 12.0.6 → 12.0.8

package/Server/Utils/DataSource/EgressGuard.ts

@@ -1,16 +1,26 @@
 import dns from "dns";
+import http from "http";
+import https from "https";
 import net from "net";
 import BadDataException from "../../../Types/Exception/BadDataException";
-import { IsBillingEnabled } from "../../EnvironmentConfig";
 
 /*
- * SSRF egress guard for external Data Source connections.
+ * SSRF egress guard for outbound connections whose target is chosen by a
+ * tenant.
  *
- * Data Sources let project members point OneUptime at arbitrary
- * hosts — which would otherwise turn the API server into an authenticated
- * request proxy into whatever network it runs in (cloud metadata endpoints,
- * internal services, sibling tenants' infrastructure). Every connector must
- * validate its target through this guard before opening a socket.
+ * It started life guarding external Data Source connections — hence the
+ * file's home — but the same policy now covers every sink where a project
+ * member picks the host and a self-hosted install may legitimately point at
+ * something internal: LLM providers (self-hosted Ollama/vLLM), SMTP OAuth
+ * token endpoints, status page / dashboard domain verification, OIDC
+ * discovery and Runbook HTTP steps. Sinks that can only ever be third-party
+ * SaaS (Slack, Teams, subscriber webhooks) use SSRFProtection instead, which
+ * blocks private ranges unconditionally.
+ *
+ * Without a guard these turn the API server into an authenticated request
+ * proxy into whatever network it runs in (cloud metadata endpoints, internal
+ * services, sibling tenants' infrastructure). Every caller must validate its
+ * target through this guard before opening a socket.
  *
  * Policy:
  *  - ALWAYS blocked, in every deployment: loopback, link-local (cloud
@@ -51,8 +61,38 @@ export interface EgressGuardOptions {
   blockPrivateAddresses?: boolean | undefined;
   // Test seam for DNS. Undefined ⇒ dns.promises.lookup with a timeout.
   resolveFunction?: EgressResolveFunction | undefined;
+  /*
+   * Noun used in error messages so a rejection names the thing the user was
+   * actually configuring ("LLM provider host ... is not allowed"). Defaults
+   * to "Data source".
+   */
+  targetLabel?: string | undefined;
+}
+
+export interface PinnedAgents {
+  httpAgent: http.Agent;
+  httpsAgent: https.Agent;
 }
 
+/*
+ * dns.lookup's shape, as http.Agent / net.Socket call it. Declared locally
+ * rather than pulled from @types/node because the real declaration is a heavy
+ * overload set and every consumer here uses exactly this one shape.
+ */
+export type EgressLookupCallback = (
+  error: NodeJS.ErrnoException | null,
+  address: string | Array<{ address: string; family: number }>,
+  family?: number,
+) => void;
+
+export type EgressLookupFunction = (
+  hostname: string,
+  options: { all?: boolean | undefined; family?: number | undefined },
+  callback: EgressLookupCallback,
+) => void;
+
+const DEFAULT_TARGET_LABEL: string = "Data source";
+
 export interface AddressVerdict {
   blocked: boolean;
   reason?: string | undefined;
@@ -93,7 +133,15 @@ export default class DataSourceEgressGuard {
     if (process.env["DATA_SOURCE_BLOCK_PRIVATE_ADDRESSES"] === "true") {
       return true;
     }
-    return IsBillingEnabled;
+    /*
+     * Read BILLING_ENABLED at call time rather than the boot-time
+     * IsBillingEnabled const, so this policy is consistent with the env
+     * override checked above and can be exercised deterministically in tests
+     * (a self-hosted install with billing off must still be able to reach its
+     * own private ranges). In a running deployment the env is fixed at boot,
+     * so this is behaviourally identical to the const.
+     */
+    return process.env["BILLING_ENABLED"] === "true";
   }
 
   private static ipv4ToInt(ip: string): number {
@@ -352,8 +400,10 @@ export default class DataSourceEgressGuard {
     hostname: string,
     options?: EgressGuardOptions,
   ): Promise<Array<ResolvedAddress>> {
+    const label: string = options?.targetLabel || DEFAULT_TARGET_LABEL;
+
     if (!hostname) {
-      throw new BadDataException("Data source host is required.");
+      throw new BadDataException(`${label} host is required.`);
     }
 
     // Literal [::1] style hosts arrive with brackets from URL parsing.
@@ -363,7 +413,7 @@ export default class DataSourceEgressGuard {
       const verdict: AddressVerdict = this.checkAddress(bareHostname, options);
       if (verdict.blocked) {
         throw new BadDataException(
-          `Data source host ${bareHostname} is not allowed: ${verdict.reason}.`,
+          `${label} host ${bareHostname} is not allowed: ${verdict.reason}.`,
         );
       }
       return [{ address: bareHostname, family: net.isIP(bareHostname) }];
@@ -380,7 +430,7 @@ export default class DataSourceEgressGuard {
       addresses = await resolveFunction(bareHostname);
     } catch (error) {
       throw new BadDataException(
-        `Could not resolve data source host ${bareHostname}: ${
+        `Could not resolve ${label.toLowerCase()} host ${bareHostname}: ${
           error instanceof Error ? error.message : String(error)
         }`,
       );
@@ -388,7 +438,7 @@ export default class DataSourceEgressGuard {
 
     if (addresses.length === 0) {
       throw new BadDataException(
-        `Could not resolve data source host ${bareHostname}.`,
+        `Could not resolve ${label.toLowerCase()} host ${bareHostname}.`,
       );
     }
 
@@ -399,7 +449,7 @@ export default class DataSourceEgressGuard {
       );
       if (verdict.blocked) {
         throw new BadDataException(
-          `Data source host ${bareHostname} resolves to ${resolved.address}, which is not allowed: ${verdict.reason}.`,
+          `${label} host ${bareHostname} resolves to ${resolved.address}, which is not allowed: ${verdict.reason}.`,
         );
       }
     }
@@ -416,20 +466,24 @@ export default class DataSourceEgressGuard {
     urlString: string,
     options?: EgressGuardOptions,
   ): Promise<{ url: URL; addresses: Array<ResolvedAddress> }> {
+    const label: string = options?.targetLabel || DEFAULT_TARGET_LABEL;
+
     if (!urlString) {
-      throw new BadDataException("Data source URL is required.");
+      throw new BadDataException(`${label} URL is required.`);
     }
 
     let url: URL;
     try {
       url = new URL(urlString);
     } catch {
-      throw new BadDataException(`Invalid data source URL: ${urlString}`);
+      throw new BadDataException(
+        `Invalid ${label.toLowerCase()} URL: ${urlString}`,
+      );
     }
 
     if (url.protocol !== "http:" && url.protocol !== "https:") {
       throw new BadDataException(
-        `Data source URL must use http or https (got ${url.protocol.replace(
+        `${label} URL must use http or https (got ${url.protocol.replace(
           ":",
           "",
         )}).`,
@@ -443,4 +497,110 @@ export default class DataSourceEgressGuard {
 
     return { url, addresses };
   }
+
+  /*
+   * A dns.lookup-shaped function that always answers with the already
+   * validated addresses. Handing this to an http(s).Agent makes the address
+   * that was checked the address that gets dialed, closing the DNS-rebind
+   * window between validation and connect. TLS still verifies against the
+   * original hostname because SNI is taken from the URL, not from here.
+   */
+  public static createPinnedLookup(
+    addresses: Array<ResolvedAddress>,
+  ): EgressLookupFunction {
+    return (
+      _hostname: string,
+      lookupOptions: { all?: boolean | undefined },
+      callback: EgressLookupCallback,
+    ): void => {
+      if (lookupOptions && lookupOptions.all) {
+        callback(
+          null,
+          addresses.map((resolved: ResolvedAddress) => {
+            return { address: resolved.address, family: resolved.family };
+          }),
+        );
+        return;
+      }
+
+      const first: ResolvedAddress = addresses[0]!;
+      callback(null, first.address, first.family);
+    };
+  }
+
+  // http/https agent pair that dials only the given validated addresses.
+  public static createPinnedAgents(
+    addresses: Array<ResolvedAddress>,
+  ): PinnedAgents {
+    const lookup: EgressLookupFunction = this.createPinnedLookup(addresses);
+
+    return {
+      httpAgent: new http.Agent({ lookup: lookup as never }),
+      httpsAgent: new https.Agent({ lookup: lookup as never }),
+    };
+  }
+
+  /*
+   * Validate a URL and return agents pinned to what it resolved to — the
+   * one-call form for HTTP callers. Pair with maxRedirects 0 /
+   * doNotFollowRedirects: pinning only covers the host that was validated, so
+   * a 3xx to an unvalidated host would otherwise walk straight around it.
+   */
+  public static async assertUrlAllowedAndPin(
+    urlString: string,
+    options?: EgressGuardOptions,
+  ): Promise<{ url: URL; addresses: Array<ResolvedAddress> } & PinnedAgents> {
+    const { url, addresses } = await this.assertUrlAllowed(urlString, options);
+
+    return { url, addresses, ...this.createPinnedAgents(addresses) };
+  }
+
+  /*
+   * A dns.lookup-shaped function that validates every hostname it is asked
+   * about and then answers with the addresses it just checked.
+   *
+   * For libraries that build their own request URLs from documents they
+   * fetched (openid-client adopts token_endpoint/userinfo_endpoint/jwks_uri
+   * from the discovery document), pre-validating the one URL we know about
+   * fixes nothing. Installing this as the library's lookup puts the guard on
+   * every socket the library opens, whichever URL it decided to call.
+   */
+  public static createGuardedLookup(
+    options?: EgressGuardOptions,
+  ): EgressLookupFunction {
+    return (
+      hostname: string,
+      lookupOptions: { all?: boolean | undefined; family?: number | undefined },
+      callback: EgressLookupCallback,
+    ): void => {
+      this.assertHostnameAllowed(hostname, options)
+        .then((addresses: Array<ResolvedAddress>) => {
+          const wantedFamily: number | undefined =
+            lookupOptions && lookupOptions.family
+              ? lookupOptions.family
+              : undefined;
+
+          const usable: Array<ResolvedAddress> =
+            wantedFamily === 4 || wantedFamily === 6
+              ? addresses.filter((resolved: ResolvedAddress) => {
+                  return resolved.family === wantedFamily;
+                })
+              : addresses;
+
+          if (usable.length === 0) {
+            const error: NodeJS.ErrnoException = new Error(
+              `No IPv${wantedFamily} address for ${hostname}`,
+            );
+            error.code = "ENOTFOUND";
+            callback(error, "");
+            return;
+          }
+
+          this.createPinnedLookup(usable)(hostname, lookupOptions, callback);
+        })
+        .catch((error: Error) => {
+          callback(error as NodeJS.ErrnoException, "");
+        });
+    };
+  }
 }

package/Server/Utils/DataSource/HttpFetch.ts

@@ -1,5 +1,3 @@
-import http from "http";
-import https from "https";
 import axios, { AxiosRequestConfig, AxiosResponse } from "axios";
 import API from "../../../Utils/API";
 import Dictionary from "../../../Types/Dictionary";
@@ -8,10 +6,7 @@ import {
   DATA_SOURCE_MAX_RESPONSE_SIZE_IN_BYTES,
   DATA_SOURCE_QUERY_TIMEOUT_IN_MS,
 } from "../../../Types/DataSource/DataSourceLimits";
-import DataSourceEgressGuard, {
-  EgressGuardOptions,
-  ResolvedAddress,
-} from "./EgressGuard";
+import DataSourceEgressGuard, { EgressGuardOptions } from "./EgressGuard";
 import { DataSourceConnectionSettings } from "./Types";
 
 /*
@@ -54,12 +49,6 @@ export interface DataSourceHttpResponse {
   bodyJson: unknown;
 }
 
-type LookupCallback = (
-  error: NodeJS.ErrnoException | null,
-  address: string | Array<{ address: string; family: number }>,
-  family?: number,
-) => void;
-
 export default class DataSourceHttpFetch {
   /*
    * Standard auth headers for a data source: Bearer token wins, else HTTP
@@ -92,44 +81,16 @@ export default class DataSourceHttpFetch {
   public static async fetch(
     request: DataSourceHttpRequest,
   ): Promise<DataSourceHttpResponse> {
-    const { url, addresses } = await DataSourceEgressGuard.assertUrlAllowed(
-      request.url,
-      request.egressOptions,
-    );
-
     /*
      * Pin the validated addresses: whatever getaddrinfo said at validation
      * time is what the socket dials, even if DNS answers differently a
      * millisecond later.
      */
-    const pinnedLookup: (
-      hostname: string,
-      options: { all?: boolean },
-      callback: LookupCallback,
-    ) => void = (
-      _hostname: string,
-      options: { all?: boolean },
-      callback: LookupCallback,
-    ): void => {
-      const first: ResolvedAddress = addresses[0]!;
-      if (options && options.all) {
-        callback(
-          null,
-          addresses.map((resolved: ResolvedAddress) => {
-            return { address: resolved.address, family: resolved.family };
-          }),
-        );
-        return;
-      }
-      callback(null, first.address, first.family);
-    };
-
-    const httpAgent: http.Agent = new http.Agent({
-      lookup: pinnedLookup as never,
-    });
-    const httpsAgent: https.Agent = new https.Agent({
-      lookup: pinnedLookup as never,
-    });
+    const { url, httpAgent, httpsAgent } =
+      await DataSourceEgressGuard.assertUrlAllowedAndPin(
+        request.url,
+        request.egressOptions,
+      );
 
     const headers: Dictionary<string> = { ...(request.headers || {}) };
 

package/Server/Utils/Execute.ts

@@ -74,6 +74,13 @@ export default class Execute {
      * (e.g. `git log` over a huge full-history repo) can never hang the caller.
      */
     timeoutInMS?: number | undefined;
+    /*
+     * Environment for the child. Replaces this process's environment entirely
+     * when given, so a caller can hand a secret to ONE child (a git askpass
+     * token) without putting it in process.env, where every other child —
+     * including an AI agent's shell commands — would inherit it.
+     */
+    env?: NodeJS.ProcessEnv | undefined;
   }): Promise<string> {
     return new Promise(
       (
@@ -89,6 +96,7 @@ export default class Execute {
             ...(data.timeoutInMS
               ? { timeout: data.timeoutInMS, killSignal: "SIGKILL" }
               : {}),
+            ...(data.env ? { env: data.env } : {}),
           },
           (
             err: ExecFileException | null,

package/Server/Utils/InlineImageAccessTokenSync.ts

@@ -81,3 +81,26 @@ export const setIsPublicForMarkdownImages: (
     }
   }
 };
+
+/*
+ * Best-effort variant used by the publish paths (public notes,
+ * announcements). Failing to flip an inline image must never fail the
+ * write the user actually asked for, so errors are logged and swallowed.
+ */
+export const syncIsPublicForMarkdownImages: (
+  markdown: string | null | undefined,
+  isPublic: boolean,
+  context: string,
+) => Promise<void> = async (
+  markdown: string | null | undefined,
+  isPublic: boolean,
+  context: string,
+): Promise<void> => {
+  try {
+    await setIsPublicForMarkdownImages(markdown, isPublic);
+  } catch (err) {
+    logger.error(
+      `Failed to sync inline image visibility for ${context}: ${String(err)}`,
+    );
+  }
+};

package/Server/Utils/LLM/LLMService.ts

@@ -4,11 +4,12 @@ import Headers from "../../../Types/API/Headers";
 import URL from "../../../Types/API/URL";
 import { JSONArray, JSONObject } from "../../../Types/JSON";
 import JSONFunctions from "../../../Types/JSONFunctions";
-import API from "../../../Utils/API";
+import API, { RequestOptions } from "../../../Utils/API";
 import LlmType from "../../../Types/LLM/LlmType";
 import BadDataException from "../../../Types/Exception/BadDataException";
 import logger, { LogAttributes } from "../Logger";
 import CaptureSpan from "../Telemetry/CaptureSpan";
+import DataSourceEgressGuard from "../DataSource/EgressGuard";
 
 export interface LLMToolDefinition {
   name: string;
@@ -653,6 +654,38 @@ export default class LLMService {
    * the offending parameter in the 400 — one parameter per response, hence the
    * loop.
    */
+  /*
+   * Request options for a call to a tenant-configured LLM endpoint.
+   *
+   * LlmProvider.baseUrl is writable by any project member while reading the
+   * apiKey is Owner/Admin-only, so an unguarded request lets a member repoint
+   * a provider at a host they control and collect the decrypted key out of the
+   * auth header — and, because provider error bodies are reflected back
+   * through the LLM provider API, use the same lever as a blind-free read
+   * primitive against the internal network.
+   *
+   * The address the guard checked is pinned into the socket, and redirects are
+   * refused: pinning covers only the validated host, so a 3xx would walk
+   * around it. Private ranges stay reachable on self-hosted installs, because
+   * a self-hosted Ollama on 10.x is the documented deployment.
+   */
+  private static async buildGuardedRequestOptions(
+    requestUrl: string,
+    options: RequestOptions,
+  ): Promise<RequestOptions> {
+    const { httpAgent, httpsAgent } =
+      await DataSourceEgressGuard.assertUrlAllowedAndPin(requestUrl, {
+        targetLabel: "LLM provider",
+      });
+
+    return {
+      ...options,
+      doNotFollowRedirects: true,
+      httpAgent,
+      httpsAgent,
+    };
+  }
+
   private static async postOpenAIChatCompletion(data: {
     requestUrl: string;
     headers: Headers;
@@ -674,6 +707,18 @@ export default class LLMService {
      */
     const attemptedTokenLimitParams: Set<TokenLimitParam> = new Set();
 
+    /*
+     * Validated once, before the first request: the adaptation loop below
+     * re-posts to the same URL, so re-resolving per attempt would only add
+     * DNS round trips (and a rebind window between them).
+     */
+    const requestOptions: RequestOptions =
+      await this.buildGuardedRequestOptions(data.requestUrl, {
+        retries: data.request.requestRetries ?? 2,
+        exponentialBackoff: true,
+        timeout: data.request.requestTimeoutInMs ?? 120000,
+      });
+
     const post: () => Promise<
       HTTPResponse<JSONObject> | HTTPErrorResponse
     > = (): Promise<HTTPResponse<JSONObject> | HTTPErrorResponse> => {
@@ -693,11 +738,7 @@ export default class LLMService {
         url: URL.fromString(data.requestUrl),
         data: body,
         headers: data.headers,
-        options: {
-          retries: data.request.requestRetries ?? 2,
-          exponentialBackoff: true,
-          timeout: data.request.requestTimeoutInMs ?? 120000,
-        },
+        options: requestOptions,
       });
     };
 
@@ -1214,20 +1255,22 @@ export default class LLMService {
       requestData["tools"] = anthropicTools;
     }
 
+    const anthropicRequestUrl: string = `${baseUrl}/messages`;
+
     const response: HTTPErrorResponse | HTTPResponse<JSONObject> =
       await API.post<JSONObject>({
-        url: URL.fromString(`${baseUrl}/messages`),
+        url: URL.fromString(anthropicRequestUrl),
         data: requestData,
         headers: {
           "x-api-key": config.apiKey,
           "anthropic-version": "2023-06-01",
           "Content-Type": "application/json",
         },
-        options: {
+        options: await this.buildGuardedRequestOptions(anthropicRequestUrl, {
           retries: request.requestRetries ?? 2,
           exponentialBackoff: true,
           timeout: request.requestTimeoutInMs ?? 120000,
-        },
+        }),
       });
 
     const anthropicLogAttributes: LogAttributes = {
@@ -1355,18 +1398,20 @@ export default class LLMService {
       requestData["tools"] = this.toOpenAITools(request.tools);
     }
 
+    const ollamaRequestUrl: string = `${config.baseUrl}/api/chat`;
+
     const response: HTTPErrorResponse | HTTPResponse<JSONObject> =
       await API.post<JSONObject>({
-        url: URL.fromString(`${config.baseUrl}/api/chat`),
+        url: URL.fromString(ollamaRequestUrl),
         data: requestData,
         headers: {
           "Content-Type": "application/json",
         },
-        options: {
+        options: await this.buildGuardedRequestOptions(ollamaRequestUrl, {
           retries: request.requestRetries ?? 2,
           exponentialBackoff: true,
           timeout: request.requestTimeoutInMs ?? 300000, // Ollama may be slower
-        },
+        }),
       });
 
     const ollamaLogAttributes: LogAttributes = {

package/Server/Utils/Monitor/MonitorAlert.ts

@@ -36,6 +36,9 @@ import MonitorClusterContextUtil, {
   MonitorClusterContext,
 } from "./MonitorClusterContext";
 import MonitorTemplateUtil from "./MonitorTemplateUtil";
+import MonitorDependencySuppression, {
+  DependencySuppressionResult,
+} from "./MonitorDependencySuppression";
 import { JSONObject } from "../../../Types/JSON";
 import OneUptimeDate from "../../../Types/Date";
 import MonitorEvaluationSummary from "../../../Types/Monitor/MonitorEvaluationSummary";
@@ -240,6 +243,14 @@ export default class MonitorAlert {
      * evaluating. See MonitorMaintenanceSuppression.
      */
     suppressedSeriesFingerprints?: Set<string> | undefined;
+    /**
+     * Alert-dependency suppression: when set and isSuppressed, a parent
+     * monitor this monitor depends on is currently in a suppressing
+     * status, so ALL alert creation for this evaluation is skipped. Only
+     * creation — already-open alerts still follow the normal resolve
+     * path above. See MonitorDependencySuppression.
+     */
+    dependencySuppression?: DependencySuppressionResult | undefined;
     /**
      * Event-driven monitors (incoming-request / webhook fan-out) must not
      * use the metric snapshot model where a series absent from this tick's
@@ -288,6 +299,35 @@ export default class MonitorAlert {
       return;
     }
 
+    /*
+     * Alert-dependency suppression: a parent monitor is in a suppressing
+     * status (offline by default), so skip creating any alert for this
+     * evaluation. Placed after the open-alert resolve pass above on
+     * purpose — an alert raised before the parent went down must still
+     * resolve normally; only new creation is silenced.
+     */
+    if (input.dependencySuppression?.isSuppressed) {
+      const suppressionReason: string =
+        MonitorDependencySuppression.buildSuppressionReason(
+          input.dependencySuppression.suppressingParents,
+        );
+
+      logger.debug(
+        `${input.monitor.id?.toString()} - Skipping alert creation: ${suppressionReason}.`,
+        alertLogAttributes,
+      );
+
+      input.evaluationSummary?.events.push({
+        type: "alert-skipped",
+        title: "Alert suppressed by monitor dependency",
+        message: `Skipped creating alerts because ${suppressionReason}. This monitor's status still updates normally; open alerts still auto-resolve.`,
+        relatedCriteriaId: input.criteriaInstance.data?.id,
+        at: OneUptimeDate.getCurrentDate(),
+      });
+
+      return;
+    }
+
     /*
      * Proxmox/Ceph monitors: resolve the monitored cluster once per
      * evaluation (lookup-only, from the step config's clusterIdentifier)