@oneuptime/common 12.0.9 → 12.0.11

package/Types/API/URL.ts

@@ -9,6 +9,33 @@ import Protocol from "./Protocol";
 import Route from "./Route";
 import { FindOperator } from "typeorm";
 
+/*
+ * Schemes whose remainder is NOT an authority: there is no host, no port and
+ * no path to parse, so the value is carried verbatim instead of being routed
+ * through Hostname. "mailto:" is handled separately because its payload is an
+ * Email, which already has its own type.
+ */
+const OPAQUE_PROTOCOLS: Array<Protocol> = [Protocol.TEL, Protocol.SMS];
+
+/*
+ * A tel/sms subscriber per RFC 3966: an optional "+" for a global number, then
+ * digits and the visual separators the RFC permits ("-", ".", "(", ")"). At
+ * least one digit is required, but it need not come first — "(313)636-1710"
+ * opens on a separator and is a number people really write.
+ *
+ * Deliberately narrow beyond that: the point is to reject anything that could
+ * smuggle a path, query, fragment or authority ("/", "?", "#", "@",
+ * whitespace) into a value that later gets interpolated into an href.
+ */
+const TEL_SUBSCRIBER_REGEX: RegExp = /^\+?[0-9\-.()]*[0-9][0-9\-.()]*$/;
+
+/*
+ * ";key=value" parameters, e.g. ";phone-context=+1". Values are restricted to
+ * RFC 3986 unreserved characters plus the few sub-delims real numbers use.
+ */
+const TEL_PARAM_REGEX: RegExp =
+  /^[A-Za-z0-9\-._~%]+(?:=[A-Za-z0-9\-._~%+:]*)?$/;
+
 export default class URL extends DatabaseProperty {
   private _route: Route = new Route();
   public get route(): Route {
@@ -50,6 +77,75 @@ export default class URL extends DatabaseProperty {
     this._protocol = v;
   }
 
+  /*
+   * The payload of an opaque scheme — the phone number of a tel:/sms: URL.
+   * Empty for every other scheme.
+   */
+  private _opaqueValue: string = "";
+  public get opaqueValue(): string {
+    return this._opaqueValue;
+  }
+  public set opaqueValue(v: string) {
+    const value: string = v.trim();
+
+    if (!URL.isValidOpaqueValue(value)) {
+      throw new BadDataException(
+        "Phone number " + v + " is not in valid format.",
+      );
+    }
+
+    this._opaqueValue = value;
+  }
+
+  /*
+   * Set only by the lenient read paths (fromDatabase / fromJSON) when a stored
+   * value cannot be parsed. Such a URL keeps the raw string so it still
+   * round-trips and still renders, but exposes no hostname and is refused by
+   * toDatabase so the bad value can never be written back or newly created.
+   */
+  private _isMalformed: boolean = false;
+  public isMalformed(): boolean {
+    return this._isMalformed;
+  }
+
+  private _rawValue: string = "";
+
+  public static isOpaqueProtocol(protocol: Protocol): boolean {
+    return OPAQUE_PROTOCOLS.includes(protocol);
+  }
+
+  /*
+   * A tel:/sms: payload: one or more comma-separated numbers (sms: allows
+   * several recipients) followed by optional ";key=value" parameters.
+   */
+  public static isValidOpaqueValue(value: string): boolean {
+    const trimmed: string = value.trim();
+
+    if (!trimmed || trimmed.length > 256) {
+      return false;
+    }
+
+    const [subscribers, ...params] = trimmed.split(";");
+
+    if (!subscribers) {
+      return false;
+    }
+
+    const numbers: Array<string> = subscribers.split(",");
+
+    const everyNumberIsValid: boolean = numbers.every((number: string) => {
+      return TEL_SUBSCRIBER_REGEX.test(number);
+    });
+
+    if (!everyNumberIsValid) {
+      return false;
+    }
+
+    return params.every((param: string) => {
+      return TEL_PARAM_REGEX.test(param);
+    });
+  }
+
   public constructor(
     protocol: Protocol,
     hostname: Hostname | string | Email,
@@ -58,6 +154,21 @@ export default class URL extends DatabaseProperty {
   ) {
     super();
 
+    /*
+     * Opaque schemes first: their payload is a phone number, and asking
+     * Hostname to validate one would either reject it or — as it did before
+     * tel: was a known scheme — read "tel:1234567890" as host + port.
+     */
+    if (URL.isOpaqueProtocol(protocol)) {
+      this.protocol = protocol;
+      this.opaqueValue =
+        hostname instanceof Hostname || hostname instanceof Email
+          ? hostname.toString()
+          : (hostname as string);
+      this.setParamsFromQueryString(queryString);
+      return;
+    }
+
     if (
       typeof hostname === Typeof.String &&
       Email.isValid(hostname as string)
@@ -77,15 +188,21 @@ export default class URL extends DatabaseProperty {
       this.route = route;
     }
 
-    if (queryString) {
-      const keyValues: Array<string> = queryString.split("&");
-      for (const keyValue of keyValues) {
-        if (keyValue.split("=")[0] && keyValue.split("=")[1]) {
-          const key: string | undefined = keyValue.split("=")[0];
-          const value: string | undefined = keyValue.split("=")[1];
-          if (key && value) {
-            this._params[key] = value;
-          }
+    this.setParamsFromQueryString(queryString);
+  }
+
+  private setParamsFromQueryString(queryString?: string): void {
+    if (!queryString) {
+      return;
+    }
+
+    const keyValues: Array<string> = queryString.split("&");
+    for (const keyValue of keyValues) {
+      if (keyValue.split("=")[0] && keyValue.split("=")[1]) {
+        const key: string | undefined = keyValue.split("=")[0];
+        const value: string | undefined = keyValue.split("=")[1];
+        if (key && value) {
+          this._params[key] = value;
         }
       }
     }
@@ -95,7 +212,34 @@ export default class URL extends DatabaseProperty {
     return this.protocol === Protocol.HTTPS;
   }
 
+  private queryStringSuffix(): string {
+    if (Object.keys(this.params).length === 0) {
+      return "";
+    }
+
+    return (
+      "?" +
+      Object.keys(this.params)
+        .map((key: string) => {
+          return key + "=" + this.params[key];
+        })
+        .join("&")
+    );
+  }
+
   public override toString(): string {
+    /*
+     * A value that failed to parse on read is echoed back exactly as stored,
+     * so a legacy row still renders as the link it always was.
+     */
+    if (this.isMalformed()) {
+      return this._rawValue;
+    }
+
+    if (URL.isOpaqueProtocol(this.protocol)) {
+      return `${this.protocol}${this.opaqueValue}${this.queryStringSuffix()}`;
+    }
+
     let urlString: string = `${this.protocol}${this.hostname || this.email}`;
     if (!this.email && !urlString.startsWith("mailto:")) {
       if (this.route && this.route.toString().startsWith("/")) {
@@ -110,15 +254,7 @@ export default class URL extends DatabaseProperty {
         urlString += "/" + this.route.toString();
       }
 
-      if (Object.keys(this.params).length > 0) {
-        urlString += "?";
-
-        for (const key of Object.keys(this.params)) {
-          urlString += key + "=" + this.params[key] + "&";
-        }
-
-        urlString = urlString.substring(0, urlString.length - 1); // remove last &
-      }
+      urlString += this.queryStringSuffix();
     }
 
     return urlString;
@@ -128,6 +264,50 @@ export default class URL extends DatabaseProperty {
     return URL.fromString(url.toString());
   }
 
+  /*
+   * An unrecognised scheme used to be swallowed: the prefix loop simply did
+   * not match, the protocol stayed at its https default, and the rest was read
+   * as an authority. "tel:3136361710" was stored as "https://tel:3136361710/"
+   * that way — a value nobody typed, with a host of "tel", which a later,
+   * stricter Hostname then refused to read back.
+   *
+   * Anything that clearly announces a scheme this type cannot represent is now
+   * refused with a message that says so, rather than silently rewritten:
+   *
+   *  - "scheme://..." for any scheme not in the supported list, and
+   *  - the schemes that are dangerous in an href even without "//".
+   *
+   * A scheme-less "example.com:8080/hook" is deliberately still allowed: its
+   * "example.com:" looks like a scheme to a regex but is a host and port, and
+   * callers really do pass it.
+   */
+  private static rejectUnsupportedScheme(url: string): void {
+    const schemeMatch: RegExpMatchArray | null = url
+      .trim()
+      .match(/^([a-zA-Z][a-zA-Z0-9+.-]*):(\/\/)?/);
+
+    if (!schemeMatch || !schemeMatch[1]) {
+      return;
+    }
+
+    const scheme: string = schemeMatch[1].toLowerCase();
+    const hasAuthorityMarker: boolean = Boolean(schemeMatch[2]);
+
+    const isDangerousInAnHref: boolean = [
+      "javascript",
+      "data",
+      "vbscript",
+      "file",
+      "blob",
+    ].includes(scheme);
+
+    if (hasAuthorityMarker || isDangerousInAnHref) {
+      throw new BadDataException(
+        "URL scheme " + scheme + ": is not supported.",
+      );
+    }
+  }
+
   public static fromString(url: string): URL {
     let protocol: Protocol = Protocol.HTTPS;
 
@@ -146,18 +326,27 @@ export default class URL extends DatabaseProperty {
       ["ws://", Protocol.WS],
       ["mongodb://", Protocol.MONGO_DB],
       ["mailto:", Protocol.MAIL],
+      ["tel:", Protocol.TEL],
+      ["sms:", Protocol.SMS],
     ];
 
     const lowerCasedUrl: string = url.toLowerCase();
 
+    let matchedKnownScheme: boolean = false;
+
     for (const [prefix, prefixProtocol] of schemePrefixes) {
       if (lowerCasedUrl.startsWith(prefix)) {
         protocol = prefixProtocol;
         url = url.substring(prefix.length);
+        matchedKnownScheme = true;
         break;
       }
     }
 
+    if (!matchedKnownScheme) {
+      URL.rejectUnsupportedScheme(url);
+    }
+
     if (protocol === Protocol.MAIL) {
       /*
        * Hand the bare address to the constructor so it is recognised as an
@@ -170,6 +359,18 @@ export default class URL extends DatabaseProperty {
       return new URL(protocol, address, undefined, mailQueryString);
     }
 
+    if (URL.isOpaqueProtocol(protocol)) {
+      /*
+       * "sms:+15555550123?body=hi" — the number is everything before the
+       * query. There is no authority and no path, so nothing here may reach
+       * Hostname.
+       */
+      const number: string = url.split("?")[0] || "";
+      const opaqueQueryString: string = url.split("?")[1] || "";
+
+      return new URL(protocol, number, undefined, opaqueQueryString);
+    }
+
     /*
      * The authority ends at the first "/", "?" or "#". Splitting on "/" alone
      * left the query and fragment glued to the host for URLs with no path
@@ -194,7 +395,50 @@ export default class URL extends DatabaseProperty {
     return new URL(protocol, hostname, route, queryString);
   }
 
+  /*
+   * Parses like fromString, but never throws: a value it cannot understand
+   * comes back as a malformed URL that preserves the original string.
+   *
+   * This exists for READ paths only. A single unparseable row must not be able
+   * to fail the request that reads it — a status page footer link of
+   * "https://tel:1234567890/", stored years earlier by a looser validator,
+   * used to 400 the whole status page config endpoint and left the page stuck
+   * on "Loading...". Writes stay strict: see toDatabase.
+   *
+   * A malformed URL exposes NO hostname, so nothing can read a host off it and
+   * build a request. The outbound-request guards (SSRFProtection) re-parse the
+   * raw string with the WHATWG parser and never trusted this type's parse
+   * anyway, so leniency here does not widen them.
+   */
+  public static fromStringLenient(url: string): URL {
+    try {
+      return URL.fromString(url);
+    } catch {
+      return URL.createMalformed(url);
+    }
+  }
+
+  private static createMalformed(rawValue: string): URL {
+    /*
+     * Built through the opaque branch so the constructor never asks Hostname
+     * to validate the very value that just failed to parse; the placeholder is
+     * then cleared, leaving a URL with no hostname and no opaque value. The
+     * protocol reports the same https default fromString falls back to for an
+     * unrecognised scheme.
+     */
+    const url: URL = new URL(Protocol.TEL, "0");
+    url._protocol = Protocol.HTTPS;
+    url._opaqueValue = "";
+    url._isMalformed = true;
+    url._rawValue = rawValue;
+    return url;
+  }
+
   public removeQueryString(): URL {
+    if (this.isMalformed()) {
+      return this;
+    }
+
     return URL.fromString(this.toString().split("?")[0] || "");
   }
 
@@ -205,9 +449,14 @@ export default class URL extends DatabaseProperty {
     };
   }
 
+  /*
+   * Lenient for the same reason fromDatabase is: this is how a URL crosses the
+   * wire into the browser. If it threw, moving the server-side failure out of
+   * the API would only move the crash into the client that renders the link.
+   */
   public static override fromJSON(json: JSONObject): URL {
     if (json["_type"] === ObjectType.URL) {
-      return URL.fromString((json["value"] as string) || "");
+      return URL.fromStringLenient((json["value"] as string) || "");
     }
 
     throw new BadDataException("Invalid JSON: " + JSON.stringify(json));
@@ -263,6 +512,12 @@ export default class URL extends DatabaseProperty {
     return null;
   }
 
+  /*
+   * The write side stays strict. Reads tolerate a legacy value that no longer
+   * validates, but nothing may persist one: a malformed URL only ever comes
+   * from fromDatabase/fromJSON, so refusing it here stops a bad value being
+   * written back on an unrelated update, and stops a client inventing one.
+   */
   protected static override toDatabase(
     value: URL | FindOperator<URL>,
   ): string | null {
@@ -271,15 +526,26 @@ export default class URL extends DatabaseProperty {
         value = URL.fromString(value);
       }
 
+      if (value instanceof URL && value.isMalformed()) {
+        throw new BadDataException(
+          "URL " + value.toString() + " is not in valid format.",
+        );
+      }
+
       return value.toString();
     }
 
     return null;
   }
 
+  /*
+   * Lenient by design — see fromStringLenient. A row that cannot be parsed is
+   * returned as a malformed URL rather than throwing, because throwing here
+   * fails the entire query that touched the row, not just the one column.
+   */
   protected static override fromDatabase(_value: string): URL | null {
     if (_value) {
-      return URL.fromString(_value);
+      return URL.fromStringLenient(_value);
     }
 
     return null;

package/Types/Billing/PayAsYouGoPricing.ts

@@ -0,0 +1,47 @@
+/*
+ * The public pay-as-you-go rates, as advertised on
+ * https://oneuptime.com/pricing.
+ *
+ * These live in Types (and not next to the metered plans, which are
+ * server-only) because two very different places need the same numbers: the
+ * server meters and bills against them, and the dashboard has to tell a Free
+ * plan user what they are about to be charged before they commit to it. A
+ * price quoted in the product that disagrees with the price on the invoice is
+ * worse than quoting no price at all, so there is exactly one copy.
+ */
+
+// Telemetry ingest - logs, traces, metrics and profiles.
+export const TELEMETRY_PRICE_IN_USD_PER_GB: number = 0.1;
+
+/*
+ * Session replay recordings travel on the same ingestion key as the rest of
+ * telemetry but are priced well above it, on purpose - see
+ * SessionReplayDataIngestMeteredPlan. Anything that quotes "what this key
+ * costs" has to say both numbers, or it is quoting a rate 20x below what a
+ * replay-heavy project will actually be invoiced.
+ */
+export const SESSION_REPLAY_PRICE_IN_USD_PER_GB: number = 2;
+
+// The retention the per-GB telemetry prices above are quoted for.
+export const TELEMETRY_PRICE_RETENTION_IN_DAYS: number = 15;
+
+/*
+ * Active monitoring. Every monitor except a Manual one is an active monitor -
+ * see MonitorTypeHelper.isBilledAsActiveMonitor.
+ */
+export const ACTIVE_MONITOR_PRICE_IN_USD_PER_MONTH: number = 1;
+
+export const PRICING_PAGE_URL: string = "https://oneuptime.com/pricing";
+
+/**
+ * Money as the pricing page writes it: `$1` rather than `$1.00`, but `$0.10`
+ * rather than `$0.1`. In-app copy that quotes a rate should read exactly like
+ * the page the user will check it against.
+ */
+export function formatPriceInUSD(amountInUSD: number): string {
+  if (Number.isInteger(amountInUSD)) {
+    return `$${amountInUSD}`;
+  }
+
+  return `$${amountInUSD.toFixed(2)}`;
+}

package/Types/CustomField/CustomFieldType.ts

@@ -1,9 +1,37 @@
+/*
+ * The member VALUES are load-bearing beyond this enum.
+ *
+ * CustomFieldsDetail passes a definition's `customFieldType` straight through
+ * as the `fieldType` of a Detail field and of a form field, so every member
+ * here has to name a member of BOTH `FieldType` (Detail) and
+ * `FormFieldSchemaType` (Forms) by value. `Boolean` is the standing example:
+ * it reaches the form as FormFieldSchemaType.Toggle, which is spelled
+ * `Toggle = "Boolean"` for exactly this reason.
+ *
+ * Adding a member without that correspondence compiles fine and then renders
+ * an empty cell and an input the user cannot type into.
+ */
 enum CustomFieldType {
   Text = "Text",
   Number = "Number",
   Boolean = "Boolean",
   Dropdown = "Dropdown",
   MultiSelectDropdown = "MultiSelectDropdown",
+
+  /**
+   * A calendar date with no time of day — purchase date, warranty expiry,
+   * end-of-life. Stored in the `customFields` jsonb bag as an ISO-8601 string,
+   * which is what makes it comparable: ISO-8601 sorts identically as text and
+   * as an instant, so the range filters work over a jsonb key without a cast
+   * (see JSONColumnQuery.compareText).
+   */
+  Date = "Date",
+
+  /**
+   * As `Date`, but the time of day is part of the answer — last audited at,
+   * decommissioned at.
+   */
+  DateTime = "DateTime",
 }
 
 export default CustomFieldType;

package/Types/Monitor/MonitorType.ts

@@ -170,6 +170,17 @@ export class MonitorTypeHelper {
     return monitorType === MonitorType.Manual;
   }
 
+  /*
+   * Whether a monitor of this type adds to the project's Active Monitoring
+   * bill. Mirrors what the server actually meters -
+   * ActiveMonitoringMeteredPlan counts every monitor whose type is not
+   * Manual - so the dashboard can warn a Free plan user about a charge using
+   * the same rule that produces it. Manual monitors are free and unlimited.
+   */
+  public static isBilledAsActiveMonitor(monitorType: MonitorType): boolean {
+    return !this.isManualMonitor(monitorType);
+  }
+
   public static getAllMonitorTypeProps(): Array<MonitorTypeProps> {
     const monitorTypeProps: Array<MonitorTypeProps> = [
       {

package/Types/Monitor/SnmpMonitor/NetworkTopology.ts

@@ -156,6 +156,19 @@ export interface NetworkTopologyEdge {
   monitorState?: "up" | "down" | undefined;
   // Operator-supplied label, set only on manual links.
   name?: string | undefined;
+  /*
+   * Which end of this edge is the parent, when somebody has SAID so —
+   * either on the link itself or through a link rule, which is stated in
+   * child/parent labels and so knows the answer by construction.
+   *
+   * Always one of `fromNodeId`/`toNodeId`. Absent on every discovered
+   * edge: LLDP and CDP report a cable, not a hierarchy, and the direction
+   * a neighbour entry happens to be read from says nothing about which
+   * box is upstream. Layouts that draw a tree must therefore treat this as
+   * a constraint where it is present and keep inferring where it is not —
+   * absent is "not stated", never "these are peers".
+   */
+  parentNodeId?: string | undefined;
 }
 
 export default interface NetworkTopology {

package/Types/NetworkAutomation/RuleRunResult.ts

@@ -0,0 +1,121 @@
+import { JSONObject } from "../JSON";
+
+/*
+ * What a manual "Run now" of a Network Automation rule did.
+ *
+ * Both rule kinds fire automatically only when a device is created (and, for
+ * site assignment, when its identity changes or on the next poll of a device
+ * with no site), so a rule written after an estate was imported never reaches
+ * it. "Run now" closes that gap — OneUptime/oneuptime#3191 — and these are the
+ * shapes it answers with.
+ *
+ * They live in Types, not next to the services that produce them, because the
+ * dashboard renders the same counters the server computed and neither side
+ * should be restating the other's field names.
+ */
+
+/*
+ * One run of a site assignment rule. Every device the run looked at lands in
+ * exactly one bucket, which is what lets the UI explain an assignment count of
+ * zero: "nothing matched" and "everything that matched is already there" are
+ * very different answers, and a single number cannot tell them apart.
+ */
+export interface SiteAssignmentRuleRunResult {
+  // Devices in the project the run evaluated.
+  devicesEvaluated: number;
+  // Of those, the ones this rule's criteria matched.
+  devicesMatched: number;
+  // Matched devices whose site this run actually changed.
+  devicesAssigned: number;
+  // Matched devices already sitting in this rule's site.
+  devicesAlreadyInRuleSite: number;
+  /*
+   * Matched devices left alone because they are already in some OTHER site
+   * and the run was not asked to overwrite existing assignments.
+   */
+  devicesSkippedAlreadyInAnotherSite: number;
+  /*
+   * Matched devices a higher-priority rule also matches. Running one rule
+   * never does another rule's work, so these are reported rather than moved.
+   */
+  devicesClaimedByHigherPriorityRule: number;
+  // Matched devices whose update threw. Logged server-side, never fatal.
+  devicesFailed: number;
+  // True when the run stopped at its device cap with devices left over.
+  isTruncated: boolean;
+}
+
+// One run of a network device label rule.
+export interface LabelRuleRunResult {
+  // Devices in the project the run evaluated.
+  devicesEvaluated: number;
+  // Of those, the ones this rule's criteria matched.
+  devicesMatched: number;
+  /*
+   * Matched devices that gained at least one label. Lower than devicesMatched
+   * whenever a device already carries everything the rule attaches —
+   * re-running a rule is idempotent, not additive.
+   */
+  devicesLabeled: number;
+  // (device, label) pairs actually inserted.
+  labelsAttached: number;
+  // Pairs whose insert threw. Logged server-side, never fatal.
+  labelsFailed: number;
+  // True when the run stopped at its device cap with devices left over.
+  isTruncated: boolean;
+}
+
+/*
+ * A count off the wire. An absent or non-numeric field reads as zero rather
+ * than as NaN: a summary line that says "NaN devices" is worse than one that
+ * under-reports a counter the server never sent.
+ */
+function readCount(json: JSONObject, key: string): number {
+  const value: unknown = json[key];
+
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return 0;
+  }
+
+  return value;
+}
+
+export class RuleRunResultUtil {
+  public static parseSiteAssignmentRuleRunResult(
+    json: JSONObject | undefined | null,
+  ): SiteAssignmentRuleRunResult {
+    const source: JSONObject = json || {};
+
+    return {
+      devicesEvaluated: readCount(source, "devicesEvaluated"),
+      devicesMatched: readCount(source, "devicesMatched"),
+      devicesAssigned: readCount(source, "devicesAssigned"),
+      devicesAlreadyInRuleSite: readCount(source, "devicesAlreadyInRuleSite"),
+      devicesSkippedAlreadyInAnotherSite: readCount(
+        source,
+        "devicesSkippedAlreadyInAnotherSite",
+      ),
+      devicesClaimedByHigherPriorityRule: readCount(
+        source,
+        "devicesClaimedByHigherPriorityRule",
+      ),
+      devicesFailed: readCount(source, "devicesFailed"),
+      isTruncated: source["isTruncated"] === true,
+    };
+  }
+
+  public static parseLabelRuleRunResult(
+    json: JSONObject | undefined | null,
+  ): LabelRuleRunResult {
+    const source: JSONObject = json || {};
+
+    return {
+      devicesEvaluated: readCount(source, "devicesEvaluated"),
+      devicesMatched: readCount(source, "devicesMatched"),
+      devicesLabeled: readCount(source, "devicesLabeled"),
+      labelsAttached: readCount(source, "labelsAttached"),
+      labelsFailed: readCount(source, "labelsFailed"),
+      isTruncated: source["isTruncated"] === true,
+    };
+  }
+}

package/Types/Runbook/RunbookStepType.ts

@@ -33,3 +33,26 @@ export const RUNNER_EXECUTED_STEP_TYPES: Array<RunbookStepType> = [
 export function isRunnerExecutedStepType(type: RunbookStepType): boolean {
   return RUNNER_EXECUTED_STEP_TYPES.includes(type);
 }
+
+/*
+ * Runner-executed step types that act on a system OTHER than the Runner's own
+ * host. They are dispatched as structured instructions (RunnerJob.payload)
+ * plus a credential the server resolves at claim time — never as a script, so
+ * their job rows carry an empty script by design.
+ *
+ * That is why RunnerJob.script is not a required column: an empty string is
+ * falsy, so a required-column check would reject exactly these jobs. The real
+ * rule — script types need a script, these need a payload — is per-type and
+ * therefore lives in RunnerJobService.enqueue rather than in column metadata.
+ *
+ * Every runner-executed type not listed here carries a script instead; the
+ * two sets are complementary and a test asserts they stay that way.
+ */
+export const PAYLOAD_CARRYING_STEP_TYPES: Array<RunbookStepType> = [
+  RunbookStepType.SSH,
+  RunbookStepType.Kubernetes,
+];
+
+export function isPayloadCarryingStepType(type: RunbookStepType): boolean {
+  return PAYLOAD_CARRYING_STEP_TYPES.includes(type);
+}