@oneuptime/common 10.0.66 → 10.0.67

package/Server/Services/UserTelegramService.ts

@@ -0,0 +1,140 @@
+import { IsBillingEnabled } from "../EnvironmentConfig";
+import CreateBy from "../Types/Database/CreateBy";
+import DeleteBy from "../Types/Database/DeleteBy";
+import { OnCreate, OnDelete } from "../Types/Database/Hooks";
+import DatabaseService from "./DatabaseService";
+import ProjectService from "./ProjectService";
+import UserNotificationRuleService from "./UserNotificationRuleService";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
+import BadDataException from "../../Types/Exception/BadDataException";
+import ObjectID from "../../Types/ObjectID";
+import Text from "../../Types/Text";
+import Project from "../../Models/DatabaseModels/Project";
+import Model from "../../Models/DatabaseModels/UserTelegram";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<Model>,
+  ): Promise<OnDelete<Model>> {
+    const itemsToDelete: Array<Model> = await this.findBy({
+      query: deleteBy.query,
+      select: {
+        _id: true,
+        projectId: true,
+      },
+      skip: 0,
+      limit: LIMIT_MAX,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    for (const item of itemsToDelete) {
+      await UserNotificationRuleService.deleteBy({
+        query: {
+          userTelegramId: item.id!,
+          projectId: item.projectId!,
+        },
+        limit: LIMIT_MAX,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+
+    return {
+      deleteBy,
+      carryForward: null,
+    };
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    if (!createBy.props.isRoot && createBy.data.isVerified) {
+      throw new BadDataException("isVerified cannot be set to true");
+    }
+
+    if (!createBy.props.isRoot && createBy.data.telegramChatId) {
+      throw new BadDataException("telegramChatId cannot be set directly");
+    }
+
+    const project: Project | null = await ProjectService.findOneById({
+      id: createBy.data.projectId!,
+      props: {
+        isRoot: true,
+      },
+      select: {
+        enableTelegramNotifications: true,
+        smsOrCallCurrentBalanceInUSDCents: true,
+      },
+    });
+
+    if (!project) {
+      throw new BadDataException("Project not found");
+    }
+
+    if (!project.enableTelegramNotifications) {
+      throw new BadDataException(
+        "Telegram notifications are disabled for this project. Please enable them in Project Settings > Notification Settings.",
+      );
+    }
+
+    if (
+      (project.smsOrCallCurrentBalanceInUSDCents as number) <= 100 &&
+      IsBillingEnabled
+    ) {
+      throw new BadDataException(
+        "Your notification balance is low. Please recharge your balance in Project Settings > Notification Settings.",
+      );
+    }
+
+    return {
+      createBy,
+      carryForward: null,
+    };
+  }
+
+  @CaptureSpan()
+  public async regenerateVerificationCode(itemId: ObjectID): Promise<void> {
+    const item: Model | null = await this.findOneById({
+      id: itemId,
+      props: {
+        isRoot: true,
+      },
+      select: {
+        isVerified: true,
+      },
+    });
+
+    if (!item) {
+      throw new BadDataException(
+        "Item with ID " + itemId.toString() + " not found",
+      );
+    }
+
+    if (item.isVerified) {
+      throw new BadDataException("Telegram account already verified");
+    }
+
+    await this.updateOneById({
+      id: itemId,
+      props: {
+        isRoot: true,
+      },
+      data: {
+        verificationCode: Text.generateRandomNumber(6),
+      },
+    });
+  }
+}
+
+export default new Service();

package/Server/Utils/Monitor/MonitorResource.ts

@@ -280,22 +280,36 @@ export default class MonitorResourceUtil {
 
         logger.debug(dataToProcess);
 
-        await MonitorService.updateOneById({
-          id: monitor.id!,
-          data: {
-            serverMonitorRequestReceivedAt:
-              serverMonitorResponse.requestReceivedAt!,
-            serverMonitorResponse,
-          },
-          props: {
-            isRoot: true,
-            ignoreHooks: true,
-          },
-        });
+        /*
+         * Skip persistence when this evaluation originated from the
+         * CheckOnlineStatus cron (onlyCheckRequestReceivedAt=true). The cron
+         * re-evaluates using the already-stale value read from the DB and has
+         * no new heartbeat data to persist — writing it back would race with
+         * (and overwrite) the ingest path's fresh heartbeat update, causing
+         * the monitor to flap between Online and Offline every minute.
+         */
+        if (!serverMonitorResponse.onlyCheckRequestReceivedAt) {
+          await MonitorService.updateOneById({
+            id: monitor.id!,
+            data: {
+              serverMonitorRequestReceivedAt:
+                serverMonitorResponse.requestReceivedAt!,
+              serverMonitorResponse,
+            },
+            props: {
+              isRoot: true,
+              ignoreHooks: true,
+            },
+          });
 
-        logger.debug(
-          `${dataToProcess.monitorId.toString()} - Monitor Server Response Updated`,
-        );
+          logger.debug(
+            `${dataToProcess.monitorId.toString()} - Monitor Server Response Updated`,
+          );
+        } else {
+          logger.debug(
+            `${dataToProcess.monitorId.toString()} - Skipping Monitor Server Response persist (cron re-evaluation).`,
+          );
+        }
       }
 
       if (incomingMonitorRequest) {

package/Server/Utils/Monitor/MonitorTemplateUtil.ts

@@ -183,16 +183,10 @@ export default class MonitorTemplateUtil {
         }
       }
 
-      if (
-        data.monitorType === MonitorType.SyntheticMonitor ||
-        data.monitorType === MonitorType.CustomJavaScriptCode
-      ) {
+      if (data.monitorType === MonitorType.CustomJavaScriptCode) {
         const customCodeResponse: CustomCodeMonitorResponse | undefined = (
           data.dataToProcess as ProbeMonitorResponse
         ).customCodeMonitorResponse;
-        const syntheticResponse: SyntheticMonitorResponse[] | undefined = (
-          data.dataToProcess as ProbeMonitorResponse
-        ).syntheticMonitorResponse;
 
         storageMap = {
           executionTimeInMs: customCodeResponse?.executionTimeInMS,
@@ -202,16 +196,35 @@ export default class MonitorTemplateUtil {
           failureCause: (data.dataToProcess as ProbeMonitorResponse)
             .failureCause,
         } as JSONObject;
+      }
 
-        // Add synthetic monitor specific fields if available
-        if (syntheticResponse && syntheticResponse.length > 0) {
-          const firstResponse: SyntheticMonitorResponse = syntheticResponse[0]!;
-          if (firstResponse) {
-            storageMap["screenshots"] = firstResponse.screenshots;
-            storageMap["browserType"] = firstResponse.browserType;
-            storageMap["screenSizeType"] = firstResponse.screenSizeType;
-          }
-        }
+      if (data.monitorType === MonitorType.SyntheticMonitor) {
+        const syntheticResponse: SyntheticMonitorResponse[] | undefined = (
+          data.dataToProcess as ProbeMonitorResponse
+        ).syntheticMonitorResponse;
+
+        /*
+         * Synthetic monitors run across multiple browser / screen-size combinations.
+         * Each run is exposed through the syntheticResponses array — use
+         * {{syntheticResponses[i].*}} or {{#each syntheticResponses}} in templates.
+         */
+        storageMap = {
+          syntheticResponses: (syntheticResponse || []).map(
+            (response: SyntheticMonitorResponse) => {
+              return {
+                executionTimeInMs: response.executionTimeInMS,
+                result: response.result,
+                scriptError: response.scriptError,
+                logMessages: response.logMessages || [],
+                screenshots: response.screenshots,
+                browserType: response.browserType,
+                screenSizeType: response.screenSizeType,
+              };
+            },
+          ),
+          failureCause: (data.dataToProcess as ProbeMonitorResponse)
+            .failureCause,
+        } as JSONObject;
       }
 
       if (data.monitorType === MonitorType.SNMP) {

package/Tests/Types/Date.test.ts

@@ -1,5 +1,6 @@
 import OneUptimeDate from "../../Types/Date";
 import PositiveNumber from "../../Types/PositiveNumber";
+import Timezone from "../../Types/Timezone";
 import moment, { isMoment } from "moment";
 
 describe("class OneUptimeDate", () => {
@@ -92,4 +93,161 @@ describe("class OneUptimeDate", () => {
       OneUptimeDate.fromString("2026-04-01 14:45:31.414000000").toISOString(),
     ).toBe("2026-04-01T14:45:31.414Z");
   });
+
+  describe("getZoneAbbrByTimezone (DST awareness)", () => {
+    test("returns EST for America/New_York on a winter date", () => {
+      const winterDate: Date = new Date("2026-01-15T12:00:00Z");
+      expect(
+        OneUptimeDate.getZoneAbbrByTimezone(
+          Timezone.AmericaNew_York,
+          winterDate,
+        ),
+      ).toBe("EST");
+    });
+
+    test("returns EDT for America/New_York on a summer date", () => {
+      const summerDate: Date = new Date("2026-07-15T12:00:00Z");
+      expect(
+        OneUptimeDate.getZoneAbbrByTimezone(
+          Timezone.AmericaNew_York,
+          summerDate,
+        ),
+      ).toBe("EDT");
+    });
+
+    test("returns PST for America/Los_Angeles on a winter date", () => {
+      const winterDate: Date = new Date("2026-01-15T12:00:00Z");
+      expect(
+        OneUptimeDate.getZoneAbbrByTimezone(
+          Timezone.AmericaLos_Angeles,
+          winterDate,
+        ),
+      ).toBe("PST");
+    });
+
+    test("returns PDT for America/Los_Angeles on a summer date", () => {
+      const summerDate: Date = new Date("2026-07-15T12:00:00Z");
+      expect(
+        OneUptimeDate.getZoneAbbrByTimezone(
+          Timezone.AmericaLos_Angeles,
+          summerDate,
+        ),
+      ).toBe("PDT");
+    });
+
+    test("returns UTC for UTC regardless of date", () => {
+      const winterDate: Date = new Date("2026-01-15T12:00:00Z");
+      const summerDate: Date = new Date("2026-07-15T12:00:00Z");
+      expect(
+        OneUptimeDate.getZoneAbbrByTimezone(Timezone.UTC, winterDate),
+      ).toBe("UTC");
+      expect(
+        OneUptimeDate.getZoneAbbrByTimezone(Timezone.UTC, summerDate),
+      ).toBe("UTC");
+    });
+
+    test("returns IST for Asia/Kolkata year-round (no DST)", () => {
+      const winterDate: Date = new Date("2026-01-15T12:00:00Z");
+      const summerDate: Date = new Date("2026-07-15T12:00:00Z");
+      expect(
+        OneUptimeDate.getZoneAbbrByTimezone(Timezone.AsiaKolkata, winterDate),
+      ).toBe("IST");
+      expect(
+        OneUptimeDate.getZoneAbbrByTimezone(Timezone.AsiaKolkata, summerDate),
+      ).toBe("IST");
+    });
+
+    test("returns correct abbreviation right after US DST spring-forward", () => {
+      // US DST begins 2026-03-08 at 02:00 local -> springs to 03:00 EDT.
+      const beforeDst: Date = new Date("2026-03-08T06:00:00Z"); // 01:00 EST
+      const afterDst: Date = new Date("2026-03-08T08:00:00Z"); // 04:00 EDT
+      expect(
+        OneUptimeDate.getZoneAbbrByTimezone(
+          Timezone.AmericaNew_York,
+          beforeDst,
+        ),
+      ).toBe("EST");
+      expect(
+        OneUptimeDate.getZoneAbbrByTimezone(Timezone.AmericaNew_York, afterDst),
+      ).toBe("EDT");
+    });
+
+    test("accepts an ISO date string", () => {
+      expect(
+        OneUptimeDate.getZoneAbbrByTimezone(
+          Timezone.AmericaNew_York,
+          "2026-01-15T12:00:00Z",
+        ),
+      ).toBe("EST");
+      expect(
+        OneUptimeDate.getZoneAbbrByTimezone(
+          Timezone.AmericaNew_York,
+          "2026-07-15T12:00:00Z",
+        ),
+      ).toBe("EDT");
+    });
+
+    test("falls back to current date when no date is passed (backward compat)", () => {
+      const abbr: string = OneUptimeDate.getZoneAbbrByTimezone(Timezone.UTC);
+      expect(abbr).toBe("UTC");
+    });
+  });
+
+  describe("getDateAsFormattedArrayInMultipleTimezones (DST awareness)", () => {
+    test("shows EST for a winter event in America/New_York", () => {
+      const result: Array<string> =
+        OneUptimeDate.getDateAsFormattedArrayInMultipleTimezones({
+          date: new Date("2026-01-15T17:00:00Z"),
+          timezones: [Timezone.AmericaNew_York],
+          use12HourFormat: true,
+        });
+      expect(result).toHaveLength(1);
+      expect(result[0]).toContain("EST");
+      expect(result[0]).not.toContain("EDT");
+      // 17:00 UTC in winter EST (UTC-5) = 12:00 PM
+      expect(result[0]).toContain("12:00 PM");
+    });
+
+    test("shows EDT for a summer event in America/New_York", () => {
+      const result: Array<string> =
+        OneUptimeDate.getDateAsFormattedArrayInMultipleTimezones({
+          date: new Date("2026-07-15T17:00:00Z"),
+          timezones: [Timezone.AmericaNew_York],
+          use12HourFormat: true,
+        });
+      expect(result).toHaveLength(1);
+      expect(result[0]).toContain("EDT");
+      expect(result[0]).not.toContain("EST");
+      // 17:00 UTC in summer EDT (UTC-4) = 01:00 PM
+      expect(result[0]).toContain("01:00 PM");
+    });
+
+    test("picks the correct abbreviation per-timezone for the same event", () => {
+      // A winter event in multiple zones: NY should say EST, LA should say PST, UTC stays UTC.
+      const result: Array<string> =
+        OneUptimeDate.getDateAsFormattedArrayInMultipleTimezones({
+          date: new Date("2026-01-15T17:00:00Z"),
+          timezones: [
+            Timezone.UTC,
+            Timezone.AmericaNew_York,
+            Timezone.AmericaLos_Angeles,
+          ],
+          use12HourFormat: true,
+        });
+      expect(result[0]).toContain("UTC");
+      expect(result[1]).toContain("EST");
+      expect(result[2]).toContain("PST");
+    });
+
+    test("omits the abbreviation when onlyShowDate is true", () => {
+      const result: Array<string> =
+        OneUptimeDate.getDateAsFormattedArrayInMultipleTimezones({
+          date: new Date("2026-07-15T17:00:00Z"),
+          timezones: [Timezone.AmericaNew_York],
+          onlyShowDate: true,
+        });
+      expect(result[0]).not.toContain("EDT");
+      expect(result[0]).not.toContain("EST");
+    });
+  });
 });

package/Types/Date.ts

@@ -1406,7 +1406,7 @@ export default class OneUptimeDate {
           " " +
           (onlyShowDate
             ? ""
-            : this.getZoneAbbrByTimezone(timezones[i] as Timezone)),
+            : this.getZoneAbbrByTimezone(timezones[i] as Timezone, date)),
       );
     }
 
@@ -1497,8 +1497,17 @@ export default class OneUptimeDate {
     return this.getZoneAbbrByTimezone(this.getCurrentTimezone());
   }
 
-  public static getZoneAbbrByTimezone(timezone: Timezone): string {
-    let zoneAbbr: string = moment.tz(timezone).zoneAbbr();
+  public static getZoneAbbrByTimezone(
+    timezone: Timezone,
+    date?: string | Date | undefined,
+  ): string {
+    /*
+     * Pass the reference date into moment so the abbreviation reflects DST
+     * at that date (e.g. EST in winter, EDT in summer) rather than "now".
+     */
+    let zoneAbbr: string = date
+      ? moment(this.fromString(date)).tz(timezone).zoneAbbr()
+      : moment.tz(timezone).zoneAbbr();
 
     if (zoneAbbr.startsWith("+") || zoneAbbr.startsWith("-")) {
       zoneAbbr = "GMT" + zoneAbbr;

package/Types/Icon/IconProp.ts

@@ -141,6 +141,7 @@ enum IconProp {
   SquareStack3D = "SquareStack3D",
   ExclaimationCircle = "ExclaimationCircle",
   WhatsApp = "WhatsApp",
+  Telegram = "Telegram",
   Brain = "Brain",
   FlowDiagram = "FlowDiagram",
   GitHub = "GitHub",

package/Types/Permission.ts

@@ -270,6 +270,7 @@ enum Permission {
 
   ReadSmsLog = "ReadSmsLog",
   ReadWhatsAppLog = "ReadWhatsAppLog",
+  ReadTelegramLog = "ReadTelegramLog",
   ReadEmailLog = "ReadEmailLog",
   ReadCallLog = "ReadCallLog",
   ReadPushLog = "ReadPushLog",
@@ -4520,6 +4521,16 @@ export class PermissionHelper {
         group: PermissionGroup.NotificationLog,
       },
 
+      {
+        permission: Permission.ReadTelegramLog,
+        title: "Read Telegram Log",
+        description: "This permission can read Telegram Log of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.NotificationLog,
+      },
+
       {
         permission: Permission.ReadCallLog,
         title: "Read Call Log",

package/Types/Telegram/TelegramMessage.ts

@@ -0,0 +1,9 @@
+export interface TelegramMessagePayload {
+  body: string;
+  parseMode?: "MarkdownV2" | "HTML" | undefined;
+  disableWebPagePreview?: boolean | undefined;
+}
+
+export default interface TelegramMessage extends TelegramMessagePayload {
+  to: string;
+}

package/Types/TelegramStatus.ts

@@ -0,0 +1,14 @@
+enum TelegramStatus {
+  Success = "Success",
+  Sent = "Sent",
+  Delivered = "Delivered",
+  Read = "Read",
+  Failed = "Failed",
+  Queued = "Queued",
+  Error = "Error",
+  LowBalance = "Low Balance",
+  NotVerified = "Not Verified",
+  Unknown = "Unknown",
+}
+
+export default TelegramStatus;

package/UI/Components/Icon/Icon.tsx

@@ -1075,6 +1075,21 @@ const Icon: FunctionComponent<ComponentProps> = ({
         />
       </>,
     );
+  } else if (icon === IconProp.Telegram) {
+    return getSvgWrapper(
+      <>
+        <path
+          strokeLinecap="round"
+          strokeLinejoin="round"
+          d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2z"
+        />
+        <path
+          strokeLinecap="round"
+          strokeLinejoin="round"
+          d="M7 12.5l2.5 1 1 3 2-2.5 3.5 2.5 1.5-8L6 11l1 1.5z"
+        />
+      </>,
+    );
   } else if (icon === IconProp.Hide) {
     return getSvgWrapper(
       <path

package/build/dist/Models/DatabaseModels/GlobalConfig.js

@@ -62,6 +62,9 @@ let GlobalConfig = class GlobalConfig extends GlobalConfigModel {
         this.metaWhatsAppAppId = undefined;
         this.metaWhatsAppAppSecret = undefined;
         this.metaWhatsAppWebhookVerifyToken = undefined;
+        this.telegramBotToken = undefined;
+        this.telegramBotUsername = undefined;
+        this.telegramWebhookSecretToken = undefined;
         this.emailServerType = undefined;
         this.sendgridApiKey = undefined;
         this.sendgridFromEmail = undefined;
@@ -548,6 +551,62 @@ __decorate([
     }),
     __metadata("design:type", String)
 ], GlobalConfig.prototype, "metaWhatsAppWebhookVerifyToken", void 0);
+__decorate([
+    ColumnAccessControl({
+        create: [],
+        read: [],
+        update: [],
+    }),
+    TableColumn({
+        type: TableColumnType.VeryLongText,
+        title: "Telegram Bot Token",
+        description: "Bot token issued by @BotFather for sending Telegram messages.",
+    }),
+    Column({
+        type: ColumnType.VeryLongText,
+        nullable: true,
+        unique: true,
+    }),
+    __metadata("design:type", String)
+], GlobalConfig.prototype, "telegramBotToken", void 0);
+__decorate([
+    ColumnAccessControl({
+        create: [],
+        read: [],
+        update: [],
+    }),
+    TableColumn({
+        type: TableColumnType.ShortText,
+        title: "Telegram Bot Username",
+        description: "Username of your OneUptime Telegram bot (without the leading @). Used to build verification deep links.",
+    }),
+    Column({
+        type: ColumnType.ShortText,
+        length: ColumnLength.ShortText,
+        nullable: true,
+        unique: true,
+    }),
+    __metadata("design:type", String)
+], GlobalConfig.prototype, "telegramBotUsername", void 0);
+__decorate([
+    ColumnAccessControl({
+        create: [],
+        read: [],
+        update: [],
+    }),
+    TableColumn({
+        type: TableColumnType.ShortText,
+        title: "Telegram Webhook Secret Token",
+        description: "Secret token passed to Telegram setWebhook. Telegram sends it back in the X-Telegram-Bot-Api-Secret-Token header.",
+    }),
+    Column({
+        type: ColumnType.ShortText,
+        length: ColumnLength.ShortText,
+        nullable: true,
+        unique: true,
+    }),
+    __metadata("design:type", String)
+], GlobalConfig.prototype, "telegramWebhookSecretToken", void 0);
 __decorate([
     ColumnAccessControl({
         create: [],