@oneuptime/common 12.0.0 → 12.0.1

package/Models/DatabaseModels/OnCallDutyPolicyScheduleLayer.ts

@@ -571,10 +571,19 @@ export default class OnCallDutyPolicyScheduleLayer extends BaseModel {
       Permission.EditOnCallDutyPolicyScheduleLayer,
     ],
   })
+  /*
+   * The default is `.toJSON()` rather than the Recurring instance itself. Both
+   * serialize to the identical JSON, so the DDL is unchanged — but TypeORM
+   * compares a jsonb default by deep-comparing the entity default against the
+   * value parsed back out of the database, and that comparison rejects any pair
+   * whose constructors differ (OrmUtils.compare2Objects). An instance never
+   * equals the plain object Postgres hands back, so every generated migration
+   * re-emitted this SET DEFAULT as phantom drift. A plain object compares equal.
+   */
   @Column({
     nullable: false,
     type: ColumnType.JSON,
-    default: Recurring.getDefault(),
+    default: Recurring.getDefault().toJSON(),
     transformer: Recurring.getDatabaseTransformer(),
   })
   public rotation?: Recurring = undefined;
@@ -654,10 +663,11 @@ export default class OnCallDutyPolicyScheduleLayer extends BaseModel {
       Permission.EditOnCallDutyPolicyScheduleLayer,
     ],
   })
+  // Plain object, not the instance — see the note on `rotation` above.
   @Column({
     nullable: false,
     type: ColumnType.JSON,
-    default: RestrictionTimes.getDefault(),
+    default: RestrictionTimes.getDefault().toJSON(),
     transformer: RestrictionTimes.getDatabaseTransformer(),
   })
   public restrictionTimes?: RestrictionTimes = undefined;

package/Server/Infrastructure/Postgres/LocalMigrationGenerationDataSource.ts

@@ -1,10 +1,20 @@
 import dataSourceOptions from "./DataSourceOptions";
 import { DataSource } from "typeorm";
 
+/*
+ * The app reaches Postgres over the compose network as `postgres:5432`, but the
+ * migration CLI runs on the host, where the same server is published on
+ * localhost:5400 — hence the defaults below.
+ *
+ * DATABASE_MIGRATIONS_HOST / DATABASE_MIGRATIONS_PORT (already in
+ * config.example.env, already honoured by migration-run.sh) override them, so
+ * the schema-drift job can point this at a CI service container on a different
+ * port without editing the file.
+ */
 const dataSourceOptionToMigrate: any = {
   ...dataSourceOptions,
-  host: "localhost",
-  port: 5400,
+  host: process.env["DATABASE_MIGRATIONS_HOST"] || "localhost",
+  port: parseInt(process.env["DATABASE_MIGRATIONS_PORT"] || "5400", 10),
 };
 
 const PostgresDataSource: DataSource = new DataSource(

package/Server/Services/LlmProviderService.ts

@@ -265,6 +265,68 @@ export class Service extends DatabaseService<Model> {
     });
   }
 
+  /*
+   * THE rule for "may this project use this provider?": a global provider is
+   * shared with everyone, and a project-owned provider belongs only to its
+   * own project. Every caller that honours a caller-supplied llmProviderId
+   * routes through this one predicate so the checks cannot drift apart —
+   * a second, subtly different copy of this comparison is how one entry point
+   * ends up accepting a provider another one rejects.
+   */
+  private isProviderUsableBy(provider: Model, projectId: ObjectID): boolean {
+    if (provider.isGlobalLlm === true) {
+      return true;
+    }
+
+    return Boolean(
+      provider.projectId &&
+        provider.projectId.toString() === projectId.toString(),
+    );
+  }
+
+  /*
+   * Can this project run against this provider id? Answers the question
+   * without loading secrets — callers that only need a yes/no (the runbook AI
+   * step validating a pinned provider before it runs) must not pull an apiKey
+   * into memory to get it. A provider that does not exist, or belongs to
+   * another project, is not usable.
+   */
+  @CaptureSpan()
+  public async isProviderUsableByProject(data: {
+    projectId: ObjectID;
+    llmProviderId: ObjectID;
+  }): Promise<boolean> {
+    /*
+     * _id is a uuid column: querying it with a non-uuid string is a Postgres
+     * cast error, not an empty result. A caller-supplied id reaches us
+     * straight from an unvalidated JSON config, so shape-check before the
+     * query and report "not usable" rather than throwing a driver error.
+     */
+    if (!ObjectID.isValidUUID(data.llmProviderId.toString())) {
+      return false;
+    }
+
+    const provider: Model | null = await this.findOneBy({
+      query: {
+        _id: data.llmProviderId.toString(),
+      },
+      select: {
+        _id: true,
+        projectId: true,
+        isGlobalLlm: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!provider) {
+      return false;
+    }
+
+    return this.isProviderUsableBy(provider, data.projectId);
+  }
+
   /*
    * Resolve the provider to use for a chat turn. When the user has explicitly
    * chosen a provider (llmProviderId), use it — but only if it is actually
@@ -278,7 +340,11 @@ export class Service extends DatabaseService<Model> {
     projectId: ObjectID;
     llmProviderId?: ObjectID | undefined;
   }): Promise<Model | null> {
-    if (data.llmProviderId) {
+    if (
+      data.llmProviderId &&
+      // A non-uuid id would be a Postgres cast error, not a miss. Fall back.
+      ObjectID.isValidUUID(data.llmProviderId.toString())
+    ) {
       const provider: Model | null = await this.findOneBy({
         query: {
           _id: data.llmProviderId.toString(),
@@ -300,14 +366,8 @@ export class Service extends DatabaseService<Model> {
         },
       });
 
-      if (provider) {
-        const isGlobal: boolean = provider.isGlobalLlm === true;
-        const belongsToProject: boolean =
-          provider.projectId?.toString() === data.projectId.toString();
-
-        if (isGlobal || belongsToProject) {
-          return provider;
-        }
+      if (provider && this.isProviderUsableBy(provider, data.projectId)) {
+        return provider;
       }
       // Fall through to default resolution when the id is invalid/inaccessible.
     }

package/Server/Services/RunnerService.ts

@@ -11,13 +11,7 @@ import OneUptimeDate from "../../Types/Date";
 import { JSONObject } from "../../Types/JSON";
 import QueryHelper from "../Types/Database/QueryHelper";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
-
-/*
- * How recently a Runner must have heartbeated to count as online. Matches the
- * window AIAgentService.isAgentAlive uses, and comfortably clears the Runner's
- * 60s heartbeat interval.
- */
-const RUNNER_ALIVE_WINDOW_IN_MINUTES: number = 5;
+import { RUNNER_ALIVE_WINDOW_IN_MINUTES } from "../../Types/Runner/RunnerLiveStatus";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {

package/Server/Utils/Monitor/Criteria/CompareCriteria.ts

@@ -192,6 +192,18 @@ export default class CompareCriteria {
       return null;
     }
 
+    /*
+     * parseInt("abc") returns NaN rather than throwing, and NaN is typeof
+     * "number" — so without this guard a non-numeric threshold would leak
+     * past callers that only check for `=== null`, leaving every numeric
+     * comparison silently false (value > NaN is always false). Treat an
+     * unparseable value the same as a missing one so the caller can ignore
+     * it instead of firing a broken criterion.
+     */
+    if (Number.isNaN(threshold as number)) {
+      return null;
+    }
+
     return threshold as number;
   }
 

package/Tests/App/Dashboard/RunnerInstallInstructions.test.tsx

@@ -0,0 +1,119 @@
+import "@testing-library/jest-dom";
+import { render, screen } from "@testing-library/react";
+import React from "react";
+import { describe, expect, test } from "@jest/globals";
+import RunnerInstallInstructions from "../../../../App/FeatureSet/Dashboard/src/Components/Runner/InstallInstructions";
+import ObjectID from "../../../Types/ObjectID";
+
+/*
+ * The setup card renders the docker run command with the Runner's secret key
+ * embedded in it. Reading that key is restricted to Project Owner, Project
+ * Admin and Runbook Admin (see the ColumnAccessControl on Runner.key), so for
+ * a Member or a Viewer the field simply is not in the API response.
+ *
+ * The Runners table asked for the key and passed `(item.key as string) || ""`
+ * straight through, so those users were handed a command ending in
+ * ONEUPTIME_RUNNER_KEY= with nothing after it — which copies cleanly, runs on
+ * the host, and fails there with an authentication error. These tests pin that
+ * no command is ever rendered without a key.
+ */
+
+const RUNNER_ID: ObjectID = new ObjectID("abc-123");
+
+type RenderWithKeyFunction = (key: string) => HTMLElement;
+
+const renderWithKey: RenderWithKeyFunction = (key: string): HTMLElement => {
+  const { container } = render(
+    <RunnerInstallInstructions runnerId={RUNNER_ID} runnerKey={key} />,
+  );
+
+  return container;
+};
+
+describe("RunnerInstallInstructions", () => {
+  describe("when the key is readable", () => {
+    test("renders the docker run command", () => {
+      const container: HTMLElement = renderWithKey("super-secret-key");
+
+      expect(container.textContent).toContain("docker run");
+      expect(container.textContent).toContain("oneuptime/runner:release");
+    });
+
+    test("embeds the Runner id and key", () => {
+      const container: HTMLElement = renderWithKey("super-secret-key");
+
+      expect(container.textContent).toContain("ONEUPTIME_RUNNER_ID=abc-123");
+      expect(container.textContent).toContain(
+        "ONEUPTIME_RUNNER_KEY=super-secret-key",
+      );
+    });
+
+    test("does not render the permission warning", () => {
+      renderWithKey("super-secret-key");
+
+      expect(
+        screen.queryByText(/do not have permission/i),
+      ).not.toBeInTheDocument();
+    });
+
+    /*
+     * The container needs outbound HTTPS only; saying so here is what stops
+     * someone opening an inbound hole for it.
+     */
+    test("states that the Runner needs no inbound connections", () => {
+      const container: HTMLElement = renderWithKey("super-secret-key");
+
+      expect(container.textContent).toContain(
+        "does not accept inbound connections",
+      );
+    });
+
+    /*
+     * Added because "I ran the command and it still says Never connected" is
+     * the obvious next confusion once the never-connected state exists.
+     */
+    test("explains that the first heartbeat takes up to a minute", () => {
+      const container: HTMLElement = renderWithKey("super-secret-key");
+
+      expect(container.textContent).toContain("every 60 seconds");
+      expect(container.textContent).toContain("Connected");
+    });
+  });
+
+  describe("when the key is not readable", () => {
+    test("renders the permission warning instead", () => {
+      renderWithKey("");
+
+      expect(
+        screen.getByText(
+          "You do not have permission to view this Runner's key",
+        ),
+      ).toBeInTheDocument();
+    });
+
+    /*
+     * The load-bearing assertion: no command at all, rather than a command
+     * that is silently broken.
+     */
+    test("renders no docker command at all", () => {
+      const container: HTMLElement = renderWithKey("");
+
+      expect(container.textContent).not.toContain("docker run");
+      expect(container.textContent).not.toContain("ONEUPTIME_RUNNER_KEY");
+    });
+
+    test("never emits an empty ONEUPTIME_RUNNER_KEY=", () => {
+      const container: HTMLElement = renderWithKey("");
+
+      expect(container.textContent).not.toMatch(/ONEUPTIME_RUNNER_KEY=\s/);
+    });
+
+    test("says who can supply the command", () => {
+      const container: HTMLElement = renderWithKey("");
+
+      expect(container.textContent).toContain("Project Owner");
+      expect(container.textContent).toContain("Project Admin");
+      expect(container.textContent).toContain("Runbook Admin");
+    });
+  });
+});

package/Tests/App/Dashboard/RunnerStatus.test.tsx

@@ -0,0 +1,274 @@
+import "@testing-library/jest-dom";
+import { render, screen } from "@testing-library/react";
+import React from "react";
+import { describe, expect, test } from "@jest/globals";
+import RunnerStatusElement from "../../../../App/FeatureSet/Dashboard/src/Components/Runner/RunnerStatus";
+import Runner, {
+  RunnerConnectionStatus,
+} from "../../../Models/DatabaseModels/Runner";
+import OneUptimeDate from "../../../Types/Date";
+import { JSONObject } from "../../../Types/JSON";
+
+/*
+ * The one component every Runner connection indicator in the dashboard now
+ * renders through. Three call sites used to hand-roll this, and all three read
+ * the persisted connectionStatus column — which is written on create and on
+ * the first heartbeat and never again. A Runner that died months ago still has
+ * it set to "connected".
+ *
+ * So the assertions that matter most here are the ones proving the rendered
+ * status tracks lastAlive and IGNORES connectionStatus, in both directions.
+ */
+
+type RenderRunnerFunction = (
+  runner: Runner | JSONObject,
+  showLastSeen?: boolean,
+) => void;
+
+const renderRunner: RenderRunnerFunction = (
+  runner: Runner | JSONObject,
+  showLastSeen?: boolean,
+): void => {
+  render(
+    showLastSeen === undefined ? (
+      <RunnerStatusElement runner={runner} />
+    ) : (
+      <RunnerStatusElement runner={runner} showLastSeen={showLastSeen} />
+    ),
+  );
+};
+
+type MinutesAgoFunction = (minutes: number) => Date;
+
+const minutesAgo: MinutesAgoFunction = (minutes: number): Date => {
+  return OneUptimeDate.getSomeMinutesAgo(minutes);
+};
+
+type StatusTextFunction = () => string;
+
+/*
+ * Statusbubble renders role="status" with aria-label "Status: <text>", so the
+ * accessible name is the assertion surface — it is what a screen reader
+ * announces, not just what happens to be in a div.
+ */
+const statusText: StatusTextFunction = (): string => {
+  return screen.getByRole("status").getAttribute("aria-label") || "";
+};
+
+describe("RunnerStatusElement", () => {
+  describe("never connected", () => {
+    test("a Runner with no lastAlive reads 'Never connected'", () => {
+      renderRunner({ lastAlive: null });
+
+      expect(screen.getByText("Never connected")).toBeInTheDocument();
+      expect(statusText()).toBe("Status: Never connected");
+    });
+
+    test("a Runner with lastAlive absent entirely reads 'Never connected'", () => {
+      renderRunner({});
+
+      expect(screen.getByText("Never connected")).toBeInTheDocument();
+    });
+
+    /*
+     * The whole point of the third state. A Runner created ten seconds ago
+     * whose container has not been started is not a failure, and must not be
+     * dressed as one — it used to render the same red "Disconnected" as a
+     * Runner that crashed in production.
+     */
+    test("it is not called Disconnected", () => {
+      renderRunner({ lastAlive: null });
+
+      expect(screen.queryByText("Disconnected")).not.toBeInTheDocument();
+      expect(statusText()).not.toContain("Disconnected");
+    });
+
+    test("it is grey, not red", () => {
+      const { container } = render(
+        <RunnerStatusElement runner={{ lastAlive: null }} />,
+      );
+
+      const html: string = container.innerHTML;
+
+      // Gray500 #6b7280, Red #fd625e.
+      expect(html).toContain("107, 114, 128");
+      expect(html).not.toContain("253, 98, 94");
+    });
+
+    test("it does not animate", () => {
+      const { container } = render(
+        <RunnerStatusElement runner={{ lastAlive: null }} />,
+      );
+
+      expect(container.innerHTML).not.toContain("animate-ping");
+    });
+  });
+
+  describe("connected", () => {
+    test("a heartbeat right now reads 'Connected'", () => {
+      renderRunner({ lastAlive: OneUptimeDate.getCurrentDate() });
+
+      expect(screen.getByText("Connected")).toBeInTheDocument();
+      expect(statusText()).toBe("Status: Connected");
+    });
+
+    test("a heartbeat four minutes ago still reads 'Connected'", () => {
+      renderRunner({ lastAlive: minutesAgo(4) });
+
+      expect(screen.getByText("Connected")).toBeInTheDocument();
+    });
+
+    test("it is green and animating", () => {
+      const { container } = render(
+        <RunnerStatusElement
+          runner={{ lastAlive: OneUptimeDate.getCurrentDate() }}
+        />,
+      );
+
+      // Green #2ab57d.
+      expect(container.innerHTML).toContain("42, 181, 125");
+      expect(container.innerHTML).toContain("animate-ping");
+    });
+  });
+
+  describe("disconnected", () => {
+    test("a heartbeat an hour ago reads 'Disconnected'", () => {
+      renderRunner({ lastAlive: minutesAgo(60) });
+
+      expect(statusText()).toContain("Disconnected");
+    });
+
+    /*
+     * "How long has it been gone" is the entire question when a Runner drops,
+     * and the detail card has no other column carrying it.
+     */
+    test("it appends how long ago the last heartbeat was", () => {
+      renderRunner({ lastAlive: minutesAgo(60) });
+
+      expect(statusText()).toBe("Status: Disconnected · an hour ago");
+    });
+
+    test("a day-old heartbeat says a day ago", () => {
+      renderRunner({ lastAlive: minutesAgo(60 * 24) });
+
+      expect(statusText()).toBe("Status: Disconnected · a day ago");
+    });
+
+    /*
+     * In the Runners table a Last Seen column sits directly beside this one,
+     * so repeating the relative time would be noise.
+     */
+    test("showLastSeen={false} suppresses the relative time", () => {
+      renderRunner({ lastAlive: minutesAgo(60) }, false);
+
+      expect(statusText()).toBe("Status: Disconnected");
+    });
+
+    test("showLastSeen={true} is the same as the default", () => {
+      renderRunner({ lastAlive: minutesAgo(60) }, true);
+
+      expect(statusText()).toBe("Status: Disconnected · an hour ago");
+    });
+
+    test("it is red and does not animate", () => {
+      const { container } = render(
+        <RunnerStatusElement runner={{ lastAlive: minutesAgo(60) }} />,
+      );
+
+      // Red #fd625e.
+      expect(container.innerHTML).toContain("253, 98, 94");
+      expect(container.innerHTML).not.toContain("animate-ping");
+    });
+  });
+
+  /*
+   * The regression suite. Each of these is a shape the old inline
+   * implementations got wrong.
+   */
+  describe("connectionStatus is ignored", () => {
+    test("stale lastAlive reads Disconnected even when connectionStatus says Connected", () => {
+      renderRunner({
+        connectionStatus: RunnerConnectionStatus.Connected,
+        lastAlive: minutesAgo(60 * 24 * 90),
+      });
+
+      expect(statusText()).toContain("Disconnected");
+      expect(screen.queryByText("Connected")).not.toBeInTheDocument();
+    });
+
+    test("fresh lastAlive reads Connected even when connectionStatus says Disconnected", () => {
+      renderRunner({
+        connectionStatus: RunnerConnectionStatus.Disconnected,
+        lastAlive: OneUptimeDate.getCurrentDate(),
+      });
+
+      expect(statusText()).toBe("Status: Connected");
+    });
+
+    /*
+     * Exactly what RunnerService.onBeforeCreate produces: connectionStatus
+     * defaulted to Disconnected, lastAlive still null. The user has not
+     * failed at anything yet — they have not run the Docker command.
+     */
+    test("a freshly created Runner reads Never connected, not Disconnected", () => {
+      renderRunner({
+        connectionStatus: RunnerConnectionStatus.Disconnected,
+        lastAlive: null,
+      });
+
+      expect(statusText()).toBe("Status: Never connected");
+    });
+
+    test("connectionStatus alone never produces a Connected bubble", () => {
+      renderRunner({ connectionStatus: RunnerConnectionStatus.Connected });
+
+      expect(statusText()).toBe("Status: Never connected");
+    });
+  });
+
+  describe("input shapes", () => {
+    /*
+     * The table hands over a hydrated model; ModelDetail's getElement hands
+     * over the same. The API layer hands over a plain object with an ISO
+     * string. All three have to work.
+     */
+    test("accepts a hydrated Runner model", () => {
+      const runner: Runner = new Runner();
+      runner.lastAlive = OneUptimeDate.getCurrentDate();
+
+      renderRunner(runner);
+
+      expect(statusText()).toBe("Status: Connected");
+    });
+
+    test("accepts a hydrated Runner model that never connected", () => {
+      renderRunner(new Runner());
+
+      expect(statusText()).toBe("Status: Never connected");
+    });
+
+    test("accepts an ISO string lastAlive", () => {
+      renderRunner({ lastAlive: new Date().toISOString() });
+
+      expect(statusText()).toBe("Status: Connected");
+    });
+
+    test("accepts a stale ISO string lastAlive", () => {
+      renderRunner({ lastAlive: minutesAgo(60).toISOString() });
+
+      expect(statusText()).toContain("Disconnected");
+    });
+
+    /*
+     * An unparseable timestamp must not be rendered as a healthy Runner. It
+     * falls to Disconnected, and the appended relative time is suppressed
+     * rather than printed as "Invalid date".
+     */
+    test("an unparseable lastAlive is Disconnected and prints no garbage time", () => {
+      renderRunner({ lastAlive: "not-a-date" });
+
+      expect(statusText()).toContain("Disconnected");
+      expect(statusText()).not.toContain("Invalid");
+    });
+  });
+});