@oneuptime/common 14.0.8 → 14.0.9

package/Server/API/MicrosoftTeamsAPI.ts

@@ -32,7 +32,9 @@ import ObjectID from "../../Types/ObjectID";
 import WorkspaceUserAuthTokenService from "../Services/WorkspaceUserAuthTokenService";
 import WorkspaceUserAuthToken from "../../Models/DatabaseModels/WorkspaceUserAuthToken";
 import WorkspaceType from "../../Types/Workspace/WorkspaceType";
-import MicrosoftTeamsUtil from "../Utils/Workspace/MicrosoftTeams/MicrosoftTeams";
+import MicrosoftTeamsUtil, {
+  MicrosoftTeamsChatNameRefreshResult,
+} from "../Utils/Workspace/MicrosoftTeams/MicrosoftTeams";
 import archiver, { Archiver } from "archiver";
 import LocalFile from "../Utils/LocalFile";
 import path from "path";
@@ -69,8 +71,14 @@ export default class MicrosoftTeamsAPI {
       $schema:
         "https://developer.microsoft.com/json-schemas/teams/v1.23/MicrosoftTeams.schema.json",
       manifestVersion: "1.23",
+      /*
+       * Teams only takes an uploaded package as an update when its version is
+       * higher than the installed one. Release images carry APP_VERSION; a
+       * build without it uses this fallback, so bump it whenever the manifest
+       * changes (1.6.0: ChatSettings.Read.Chat added).
+       */
       version: AppVersion.toLowerCase().includes("unknown")
-        ? "1.5.0"
+        ? "1.6.0"
         : AppVersion,
       id: MicrosoftTeamsAppClientId,
       developer: {
@@ -186,6 +194,15 @@ export default class MicrosoftTeamsAPI {
               type: "Application",
               name: "ChatMember.Read.Chat",
             },
+            /*
+             * Lets OneUptime read a group chat's name. Teams does not put it on
+             * bot activities, so without this group chats are listed by their
+             * members' names.
+             */
+            {
+              type: "Application",
+              name: "ChatSettings.Read.Chat",
+            },
             /*
              * Lets OneUptime confirm, per team, that the installed OneUptime app
              * is the package built from THIS deployment before telling an admin
@@ -209,6 +226,24 @@ export default class MicrosoftTeamsAPI {
     return manifest;
   }
 
+  // The chat list shape the Chats card reads, sorted by name.
+  private static serializeChats(
+    chats: Record<string, MicrosoftTeamsChat>,
+  ): Array<JSONObject> {
+    return Object.values(chats)
+      .sort((a: MicrosoftTeamsChat, b: MicrosoftTeamsChat) => {
+        return a.name.localeCompare(b.name);
+      })
+      .map((chat: MicrosoftTeamsChat) => {
+        return {
+          id: chat.id,
+          name: chat.name,
+          chatType: chat.chatType,
+          addedAt: chat.addedAt || null,
+        };
+      });
+  }
+
   private static getUserSignInRedirectUri(): string {
     return `${AppApiClientUrl.toString()}/microsoft-teams/auth`;
   }
@@ -1634,18 +1669,62 @@ export default class MicrosoftTeamsAPI {
             });
 
           return Response.sendJsonObjectResponse(req, res, {
-            chats: Object.values(availableChats)
-              .sort((a: MicrosoftTeamsChat, b: MicrosoftTeamsChat) => {
-                return a.name.localeCompare(b.name);
-              })
-              .map((chat: MicrosoftTeamsChat) => {
-                return {
-                  id: chat.id,
-                  name: chat.name,
-                  chatType: chat.chatType,
-                  addedAt: chat.addedAt || null,
-                };
-              }),
+            chats: MicrosoftTeamsAPI.serializeChats(availableChats),
+          });
+        } catch (err) {
+          return Response.sendErrorResponse(req, res, err as Exception);
+        }
+      },
+    );
+
+    /*
+     * "Refresh Chats". Chats still cannot be listed, but the name of each
+     * stored group chat can be re-read from Graph — which is what fixes a
+     * group chat listed under its member names, and picks up renames.
+     * Returns the same list as GET, plus which chats' names could not be read
+     * (Microsoft refused, or failed) so the page can mark them and say why.
+     *
+     * Member access, like the list: it changes nothing but the stored display
+     * names, and concurrent refreshes of a project share one run.
+     */
+    router.post(
+      "/microsoft-teams/chats/refresh",
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse) => {
+        try {
+          const databaseProps: DatabaseCommonInteractionProps =
+            await CommonAPI.getDatabaseCommonInteractionProps(req);
+
+          const projectId: ObjectID =
+            CommonAPI.assertAuthenticatedProjectMember(databaseProps);
+
+          const refreshResult: MicrosoftTeamsChatNameRefreshResult =
+            await MicrosoftTeamsUtil.refreshChatNamesForProject({
+              projectId: projectId,
+            });
+
+          // Only chats that are still listed (one may be removed mid-refresh).
+          const listed: (chatIds: Array<string>) => Array<string> = (
+            chatIds: Array<string>,
+          ): Array<string> => {
+            return chatIds.filter((chatId: string) => {
+              return Boolean(refreshResult.chats[chatId]);
+            });
+          };
+
+          const permissionDeniedChatIds: Array<string> = listed(
+            refreshResult.permissionDeniedChatIds,
+          );
+          const failedChatIds: Array<string> = listed(
+            refreshResult.failedChatIds,
+          );
+
+          return Response.sendJsonObjectResponse(req, res, {
+            chats: MicrosoftTeamsAPI.serializeChats(refreshResult.chats),
+            chatNamePermissionDeniedChatIds: permissionDeniedChatIds,
+            chatNamePermissionDeniedCount: permissionDeniedChatIds.length,
+            chatNameFailedChatIds: failedChatIds,
+            chatNameFailedCount: failedChatIds.length,
           });
         } catch (err) {
           return Response.sendErrorResponse(req, res, err as Exception);

package/Server/API/ProxmoxResourceAPI.ts

@@ -4,6 +4,7 @@ import BadDataException from "../../Types/Exception/BadDataException";
 import ObjectID from "../../Types/ObjectID";
 import ProxmoxResourceService, {
   ProxmoxInventorySummary,
+  ProxmoxRemoveNodeResult,
   Service as ProxmoxResourceServiceType,
 } from "../Services/ProxmoxResourceService";
 import ProxmoxClusterService from "../Services/ProxmoxClusterService";
@@ -17,18 +18,49 @@ import {
 } from "../Utils/Express";
 import CommonAPI from "./CommonAPI";
 import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import NotAuthorizedException from "../../Types/Exception/NotAuthorizedException";
 import NotFoundException from "../../Types/Exception/NotFoundException";
 import { JSONObject } from "../../Types/JSON";
+import ModelPermission from "../Types/Database/Permissions/Index";
+import Query from "../Types/Database/Query";
+
+// A node's pve externalId is "node/<name>" on the agent and the native push.
+const NODE_EXTERNAL_ID_PREFIX: string = "node/";
+
+/*
+ * One answer for "no such cluster in this project" and "a cluster you
+ * may not edit", so the refusal is not a way to probe for ids.
+ */
+const EDITABLE_CLUSTER_NOT_FOUND_MESSAGE: string =
+  "Proxmox Cluster not found, or you do not have permission to edit it. Removing a node needs permission to edit its cluster.";
+
+const NODE_STILL_REPORTING_MESSAGE: string =
+  "Only a node that has stopped reporting can be removed. A node that is still reporting would come back on its next report.";
+
+const NODE_NOT_FOUND_MESSAGE: string =
+  "This node is not in the cluster's inventory. It may already have been removed.";
+
+const NODE_NOT_NATIVE_MESSAGE: string =
+  "Only a node that reports over Proxmox VE's built-in metric push can be removed here. With the Proxmox Agent, a node leaves OneUptime on its own once the cluster no longer lists it.";
 
 /*
  * ------------------------------------------------------------------
  * ProxmoxResourceAPI
  *
- * Augments the auto-generated CRUD router with a single custom
- * endpoint the Proxmox layout/overview pages use to fetch sidebar
- * badge counts in one round-trip:
+ * Augments the auto-generated CRUD router with two custom endpoints:
  *
  *   POST /proxmox-resource/inventory-summary/:clusterId
+ *     Sidebar badge counts for the Proxmox layout/overview pages in
+ *     one round-trip. Needs read access to the cluster.
+ *
+ *   POST /proxmox-resource/remove-node/:clusterId   { nodeName }
+ *     Removes a node that has stopped reporting, for a node taken out
+ *     of the Proxmox cluster, which OneUptime cannot tell apart from a
+ *     dead one on the Proxmox VE native push. Its live siblings stop
+ *     reporting it as down and its Node Offline alert resolves. A node
+ *     that is still up is refused: it would come back on its next
+ *     report. Needs permission to EDIT the cluster, since users have
+ *     no write access to the inventory table itself.
  *
  * The standard CRUD endpoints (list / get) are still registered by
  * BaseAPI; the UI uses them via ModelAPI for list/detail reads.
@@ -56,6 +88,33 @@ export default class ProxmoxResourceAPI extends BaseAPI<
         }
       },
     );
+
+    this.router.post(
+      `${new this.entityType()
+        .getCrudApiPath()
+        ?.toString()}/remove-node/:clusterId`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          await this.removeNode(req, res);
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
+  }
+
+  private readClusterIdParam(req: ExpressRequest): ObjectID {
+    const clusterIdParam: string | undefined = req.params["clusterId"];
+    if (!clusterIdParam) {
+      throw new BadDataException("Cluster ID is required");
+    }
+
+    try {
+      return new ObjectID(clusterIdParam);
+    } catch {
+      throw new BadDataException("Invalid Cluster ID");
+    }
   }
 
   /*
@@ -69,17 +128,7 @@ export default class ProxmoxResourceAPI extends BaseAPI<
     projectId: ObjectID;
     proxmoxClusterId: ObjectID;
   }> {
-    const clusterIdParam: string | undefined = req.params["clusterId"];
-    if (!clusterIdParam) {
-      throw new BadDataException("Cluster ID is required");
-    }
-
-    let proxmoxClusterId: ObjectID;
-    try {
-      proxmoxClusterId = new ObjectID(clusterIdParam);
-    } catch {
-      throw new BadDataException("Invalid Cluster ID");
-    }
+    const proxmoxClusterId: ObjectID = this.readClusterIdParam(req);
 
     const props: DatabaseCommonInteractionProps =
       await CommonAPI.getDatabaseCommonInteractionProps(req);
@@ -129,4 +178,185 @@ export default class ProxmoxResourceAPI extends BaseAPI<
 
     return Response.sendJsonObjectResponse(req, res, responseBody);
   }
+
+  /*
+   * The cluster a caller removes a node from, read only if the caller
+   * may EDIT it, decided the way the cluster's own update endpoint
+   * decides it:
+   *
+   *   1. the update permission check scopes the lookup the way an update
+   *      of that row would be scoped (project, label- and Owned-scoped
+   *      grants), and the row is then read as root;
+   *   2. the per-row check the update endpoint runs before writing
+   *      (updateOneById) enforces the team block list, which the query
+   *      check does not.
+   *
+   * The project is the caller's own (props.tenantId), the only project
+   * the caller was checked in. A missing cluster, a cluster in another
+   * project and a cluster the caller may not edit all get the same
+   * NotFound.
+   */
+  private async resolveEditableClusterForRequest(
+    req: ExpressRequest,
+    proxmoxClusterId: ObjectID,
+  ): Promise<{
+    projectId: ObjectID;
+    proxmoxClusterId: ObjectID;
+  }> {
+    const props: DatabaseCommonInteractionProps =
+      await CommonAPI.getDatabaseCommonInteractionProps(req);
+
+    const projectId: ObjectID | undefined = props.tenantId;
+    if (!projectId) {
+      throw new NotFoundException(EDITABLE_CLUSTER_NOT_FOUND_MESSAGE);
+    }
+
+    let cluster: ProxmoxCluster | null = null;
+    try {
+      const editableQuery: Query<ProxmoxCluster> =
+        await ModelPermission.checkUpdateQueryPermissions(
+          ProxmoxCluster,
+          {
+            _id: proxmoxClusterId.toString(),
+            projectId: projectId,
+          },
+          {},
+          props,
+        );
+
+      cluster = await ProxmoxClusterService.findOneBy({
+        query: editableQuery,
+        select: {
+          _id: true,
+          projectId: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (cluster) {
+        /*
+         * The block check needs every label on the cluster. The lookup
+         * above is narrowed to the caller's permitted labels when the
+         * grant is label-scoped, and loading labels through it would
+         * return only those — hiding a label the caller's team is
+         * blocked on. Load them unfiltered, as updateOneById does —
+         * once, though the block and the allow checks both ask.
+         */
+        let withAllLabels: Promise<ProxmoxCluster | null> | null = null;
+        await ModelPermission.checkUpdatePermissionByModel({
+          modelType: ProxmoxCluster,
+          fetchModelWithAccessControlIds:
+            async (): Promise<ProxmoxCluster | null> => {
+              if (!withAllLabels) {
+                withAllLabels = ProxmoxClusterService.findOneById({
+                  id: proxmoxClusterId,
+                  select: {
+                    _id: true,
+                    projectId: true,
+                    labels: {
+                      _id: true,
+                    },
+                  },
+                  props: {
+                    isRoot: true,
+                  },
+                });
+              }
+              const loaded: ProxmoxCluster | null = await withAllLabels;
+              // Deleted since the lookup above: the same answer as missing.
+              if (!loaded) {
+                throw new NotFoundException(EDITABLE_CLUSTER_NOT_FOUND_MESSAGE);
+              }
+              return loaded;
+            },
+          props,
+        });
+      }
+    } catch (err) {
+      if (err instanceof NotAuthorizedException) {
+        throw new NotFoundException(EDITABLE_CLUSTER_NOT_FOUND_MESSAGE);
+      }
+      throw err;
+    }
+
+    if (!cluster || !cluster.projectId) {
+      throw new NotFoundException(EDITABLE_CLUSTER_NOT_FOUND_MESSAGE);
+    }
+
+    return {
+      projectId: cluster.projectId,
+      proxmoxClusterId,
+    };
+  }
+
+  /*
+   * The node name from the body: a non-empty string, trimmed, and a
+   * single name. The externalId is "node/<name>", so a "/" would point
+   * at something other than a node.
+   */
+  private readNodeName(req: ExpressRequest): string {
+    const body: JSONObject =
+      req.body && typeof req.body === "object" ? (req.body as JSONObject) : {};
+    const rawNodeName: unknown = body["nodeName"];
+
+    if (typeof rawNodeName !== "string" || !rawNodeName.trim()) {
+      throw new BadDataException("Node name is required");
+    }
+
+    const nodeName: string = rawNodeName.trim();
+
+    if (nodeName.includes("/")) {
+      throw new BadDataException("Node name must not contain a slash");
+    }
+
+    // Control characters (a NUL would fail in Postgres, not here).
+    for (let i: number = 0; i < nodeName.length; i++) {
+      const code: number = nodeName.charCodeAt(i);
+      if (code < 32 || code === 127) {
+        throw new BadDataException(
+          "Node name must not contain control characters",
+        );
+      }
+    }
+
+    return nodeName;
+  }
+
+  private async removeNode(
+    req: ExpressRequest,
+    res: ExpressResponse,
+  ): Promise<void> {
+    const requestedClusterId: ObjectID = this.readClusterIdParam(req);
+
+    // ObjectID accepts any string; this id goes into a Postgres uuid column.
+    if (!ObjectID.isValidUUID(requestedClusterId.toString())) {
+      throw new BadDataException("Invalid Cluster ID");
+    }
+
+    const nodeName: string = this.readNodeName(req);
+
+    const { projectId, proxmoxClusterId } =
+      await this.resolveEditableClusterForRequest(req, requestedClusterId);
+
+    const result: ProxmoxRemoveNodeResult =
+      await this.service.removeOfflineNode({
+        projectId,
+        proxmoxClusterId,
+        externalId: `${NODE_EXTERNAL_ID_PREFIX}${nodeName}`,
+      });
+
+    if (result === "not-found") {
+      throw new NotFoundException(NODE_NOT_FOUND_MESSAGE);
+    }
+    if (result === "not-native") {
+      throw new BadDataException(NODE_NOT_NATIVE_MESSAGE);
+    }
+    if (result !== "removed") {
+      throw new BadDataException(NODE_STILL_REPORTING_MESSAGE);
+    }
+
+    return Response.sendJsonObjectResponse(req, res, { removed: true });
+  }
 }

package/Server/Infrastructure/GlobalCache.ts

@@ -136,6 +136,38 @@ export default abstract class GlobalCache {
     return value;
   }
 
+  /*
+   * Several keys of one namespace in a single round-trip (MGET). The result
+   * is positional: one entry per requested key, null where the key is
+   * missing or empty.
+   */
+  @CaptureSpan()
+  public static async getStrings(
+    namespace: string,
+    keys: Array<string>,
+  ): Promise<Array<string | null>> {
+    if (keys.length === 0) {
+      return [];
+    }
+
+    const client: ClientType | null = Redis.getClient();
+
+    if (!client || !Redis.isConnected()) {
+      throw new DatabaseNotConnectedException("Cache is not connected");
+    }
+
+    const values: Array<string | null> = await client.mget(
+      keys.map((key: string) => {
+        return `${namespace}-${key}`;
+      }),
+    );
+
+    return keys.map((_key: string, index: number) => {
+      const value: string | null | undefined = values[index];
+      return value ? value : null;
+    });
+  }
+
   @CaptureSpan()
   public static async setJSON(
     namespace: string,

package/Server/Infrastructure/Postgres/SchemaMigrations/1796000000000-AddTeamComplianceRuleScope.ts

@@ -0,0 +1,99 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * Team compliance rules scoped by severity and channel.
+ *
+ * - "notificationChannel": the channel an on-call compliance rule insists on
+ *   (Call, Push, ...). Nullable with no default, so every existing rule reads
+ *   as "any channel" - exactly what it checked before.
+ * - "TeamComplianceSettingIncidentSeverity" / "...AlertSeverity": the
+ *   severities an on-call compliance rule is scoped to. Empty means every
+ *   severity, which is again what every existing rule already checked. Both
+ *   cascade from the rule and from the severity.
+ * - The unique ("teamId", "ruleType") index goes: "Call for Critical
+ *   incidents" and "Push for Critical incidents" are both
+ *   HasIncidentOnCallRules on one team. TeamComplianceSettingService rejects
+ *   exact duplicates instead. Existing data cannot violate the change - it only
+ *   relaxes a constraint.
+ */
+export class AddTeamComplianceRuleScope1796000000000
+  implements MigrationInterface
+{
+  public name: string = "AddTeamComplianceRuleScope1796000000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_ef7342919ff02501c2b0ddc029"`,
+    );
+    await queryRunner.query(
+      `CREATE TABLE "TeamComplianceSettingIncidentSeverity" ("teamComplianceSettingId" uuid NOT NULL, "incidentSeverityId" uuid NOT NULL, CONSTRAINT "PK_0071a6d21730a2ed9e098873b2e" PRIMARY KEY ("teamComplianceSettingId", "incidentSeverityId"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_013768788937d0e484fb3c1bcb" ON "TeamComplianceSettingIncidentSeverity" ("teamComplianceSettingId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_6e477b60ddefe41bfdee3e6142" ON "TeamComplianceSettingIncidentSeverity" ("incidentSeverityId") `,
+    );
+    await queryRunner.query(
+      `CREATE TABLE "TeamComplianceSettingAlertSeverity" ("teamComplianceSettingId" uuid NOT NULL, "alertSeverityId" uuid NOT NULL, CONSTRAINT "PK_ba665b5e7d6413db2be11bf2f09" PRIMARY KEY ("teamComplianceSettingId", "alertSeverityId"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_c01a8eeea98cb41a45806fe5c7" ON "TeamComplianceSettingAlertSeverity" ("teamComplianceSettingId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_573637e6a2df47b516b0f955d9" ON "TeamComplianceSettingAlertSeverity" ("alertSeverityId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "TeamComplianceSetting" ADD "notificationChannel" character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "TeamComplianceSettingIncidentSeverity" ADD CONSTRAINT "FK_013768788937d0e484fb3c1bcb8" FOREIGN KEY ("teamComplianceSettingId") REFERENCES "TeamComplianceSetting"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "TeamComplianceSettingIncidentSeverity" ADD CONSTRAINT "FK_6e477b60ddefe41bfdee3e61424" FOREIGN KEY ("incidentSeverityId") REFERENCES "IncidentSeverity"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "TeamComplianceSettingAlertSeverity" ADD CONSTRAINT "FK_c01a8eeea98cb41a45806fe5c77" FOREIGN KEY ("teamComplianceSettingId") REFERENCES "TeamComplianceSetting"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "TeamComplianceSettingAlertSeverity" ADD CONSTRAINT "FK_573637e6a2df47b516b0f955d96" FOREIGN KEY ("alertSeverityId") REFERENCES "AlertSeverity"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "TeamComplianceSettingAlertSeverity" DROP CONSTRAINT "FK_573637e6a2df47b516b0f955d96"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "TeamComplianceSettingAlertSeverity" DROP CONSTRAINT "FK_c01a8eeea98cb41a45806fe5c77"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "TeamComplianceSettingIncidentSeverity" DROP CONSTRAINT "FK_6e477b60ddefe41bfdee3e61424"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "TeamComplianceSettingIncidentSeverity" DROP CONSTRAINT "FK_013768788937d0e484fb3c1bcb8"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "TeamComplianceSetting" DROP COLUMN "notificationChannel"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_573637e6a2df47b516b0f955d9"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_c01a8eeea98cb41a45806fe5c7"`,
+    );
+    await queryRunner.query(`DROP TABLE "TeamComplianceSettingAlertSeverity"`);
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_6e477b60ddefe41bfdee3e6142"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_013768788937d0e484fb3c1bcb"`,
+    );
+    await queryRunner.query(
+      `DROP TABLE "TeamComplianceSettingIncidentSeverity"`,
+    );
+    await queryRunner.query(
+      `CREATE UNIQUE INDEX "IDX_ef7342919ff02501c2b0ddc029" ON "TeamComplianceSetting" ("teamId", "ruleType") `,
+    );
+  }
+}