@terreno/api 0.0.1

package/src/middleware.ts

@@ -0,0 +1,18 @@
+import * as Sentry from "@sentry/node";
+import type {NextFunction, Request, Response} from "express";
+
+/**
+ * Express middleware that captures the app version from the request header
+ * and adds it as a tag to the current Sentry scope.
+ *
+ * This allows filtering Sentry errors by app version.
+ *
+ * Expected header: `App-Version`
+ */
+export function sentryAppVersionMiddleware(req: Request, _res: Response, next: NextFunction): void {
+  const appVersion = req.get("App-Version");
+  if (appVersion) {
+    Sentry.getCurrentScope().setTag("app_version", appVersion);
+  }
+  next();
+}

package/src/notifiers/googleChatNotifier.test.ts

@@ -0,0 +1,114 @@
+import {afterAll, afterEach, beforeEach, describe, expect, it, type Mock, spyOn} from "bun:test";
+import * as Sentry from "@sentry/node";
+import axios from "axios";
+
+import {sendToGoogleChat} from "./googleChatNotifier";
+
+describe("sendToGoogleChat", () => {
+  let mockAxiosPost: Mock<typeof axios.post>;
+
+  const ORIGINAL_ENV = process.env;
+
+  beforeEach(() => {
+    mockAxiosPost = spyOn(axios, "post").mockResolvedValue({status: 200} as any);
+    process.env = {...ORIGINAL_ENV};
+    process.env.GOOGLE_CHAT_WEBHOOKS = undefined;
+    (Sentry.captureException as Mock<typeof Sentry.captureException>).mockClear();
+    (Sentry.captureMessage as Mock<typeof Sentry.captureMessage>).mockClear();
+  });
+
+  afterEach(() => {
+    mockAxiosPost.mockRestore();
+  });
+
+  afterAll(() => {
+    process.env = ORIGINAL_ENV;
+  });
+
+  it("returns early when GOOGLE_CHAT_WEBHOOKS is missing", async () => {
+    await sendToGoogleChat("hello");
+    expect(mockAxiosPost.mock.calls.length).toBe(0);
+  });
+
+  it("posts to default webhook with plain text", async () => {
+    process.env.GOOGLE_CHAT_WEBHOOKS = JSON.stringify({
+      default: "https://chat.example/webhook",
+    });
+    mockAxiosPost.mockResolvedValue({status: 200});
+
+    await sendToGoogleChat("hello world");
+    const callArgs = mockAxiosPost.mock.calls[0];
+    expect(Array.isArray(callArgs)).toBe(true);
+    const [url, payload] = callArgs;
+    expect(url).toBe("https://chat.example/webhook");
+    expect(payload).toEqual({text: "hello world"});
+  });
+
+  it("posts to a specific channel when provided", async () => {
+    process.env.GOOGLE_CHAT_WEBHOOKS = JSON.stringify({
+      default: "https://chat.example/default",
+      ops: "https://chat.example/ops",
+    });
+    mockAxiosPost.mockResolvedValue({status: 200});
+
+    await sendToGoogleChat("ops msg", {channel: "ops"});
+    const callArgs = mockAxiosPost.mock.calls[0];
+    expect(Array.isArray(callArgs)).toBe(true);
+    const [url, payload] = callArgs;
+    expect(url).toBe("https://chat.example/ops");
+    expect(payload).toEqual({text: "ops msg"});
+  });
+
+  it("falls back to default when channel not found", async () => {
+    process.env.GOOGLE_CHAT_WEBHOOKS = JSON.stringify({
+      default: "https://chat.example/default",
+    });
+    mockAxiosPost.mockResolvedValue({status: 200});
+
+    await sendToGoogleChat("missing channel", {channel: "unknown"});
+    const callArgs = mockAxiosPost.mock.calls[0];
+    expect(Array.isArray(callArgs)).toBe(true);
+    const [url, payload] = callArgs;
+    expect(url).toBe("https://chat.example/default");
+    expect(payload).toEqual({text: "missing channel"});
+  });
+
+  it("prefixes message with [ENV] when env provided", async () => {
+    process.env.GOOGLE_CHAT_WEBHOOKS = JSON.stringify({
+      default: "https://chat.example/default",
+    });
+    mockAxiosPost.mockResolvedValue({status: 200});
+
+    await sendToGoogleChat("status ok", {env: "prod"});
+    const callArgs = mockAxiosPost.mock.calls[0];
+    expect(Array.isArray(callArgs)).toBe(true);
+    const [, payload] = callArgs;
+    expect(payload).toEqual({text: "[PROD] status ok"});
+  });
+
+  it("captures error and throws APIError when shouldThrow=true", async () => {
+    process.env.GOOGLE_CHAT_WEBHOOKS = JSON.stringify({
+      default: "https://chat.example/default",
+    });
+    mockAxiosPost.mockRejectedValue(new Error("chat down"));
+
+    try {
+      await sendToGoogleChat("err", {shouldThrow: true});
+      throw new Error("Expected sendToGoogleChat to throw APIError");
+    } catch (error) {
+      expect((error as any).name).toBe("APIError");
+      expect((error as any).title).toMatch(/Error posting to Google Chat/i);
+    }
+    expect(mockAxiosPost.mock.calls.length).toBe(1);
+  });
+
+  it("captures error and does not throw when shouldThrow=false", async () => {
+    process.env.GOOGLE_CHAT_WEBHOOKS = JSON.stringify({
+      default: "https://chat.example/default",
+    });
+    mockAxiosPost.mockRejectedValue(new Error("chat intermittent"));
+
+    await sendToGoogleChat("err", {shouldThrow: false});
+    expect(mockAxiosPost.mock.calls.length).toBe(1);
+  });
+});

package/src/notifiers/googleChatNotifier.ts

@@ -0,0 +1,47 @@
+import * as Sentry from "@sentry/node";
+import axios from "axios";
+
+import {APIError} from "../errors";
+import {logger} from "../logger";
+
+export async function sendToGoogleChat(
+  messageText: string,
+  {channel, shouldThrow = false, env}: {channel?: string; shouldThrow?: boolean; env?: string} = {}
+) {
+  const chatWebhooksString = process.env.GOOGLE_CHAT_WEBHOOKS;
+  if (!chatWebhooksString) {
+    const msg = "GOOGLE_CHAT_WEBHOOKS not set. Google Chat message not sent";
+    Sentry.captureException(new Error(msg));
+    logger.error(msg);
+    return;
+  }
+  const chatWebhooks = JSON.parse(chatWebhooksString ?? "{}");
+
+  const chatChannel = channel ?? "default";
+  const chatWebhookUrl = chatWebhooks[chatChannel] ?? chatWebhooks.default;
+
+  if (!chatWebhookUrl) {
+    const msg = `No webhook url set in env for ${chatChannel}. Google Chat message not sent`;
+    Sentry.captureException(new Error(msg));
+    logger.error(msg);
+    return;
+  }
+
+  let formattedMessageText = messageText;
+  if (env) {
+    formattedMessageText = `[${env.toUpperCase()}] ${messageText}`;
+  }
+
+  try {
+    await axios.post(chatWebhookUrl, {text: formattedMessageText});
+  } catch (error: any) {
+    logger.error(`Error posting to Google Chat: ${error.text ?? error.message}`);
+    Sentry.captureException(error);
+    if (shouldThrow) {
+      throw new APIError({
+        status: 500,
+        title: `Error posting to Google Chat: ${error.text ?? error.message}`,
+      });
+    }
+  }
+}

package/src/notifiers/index.ts

@@ -0,0 +1,3 @@
+export * from "./googleChatNotifier";
+export * from "./slackNotifier";
+export * from "./zoomNotifier";

package/src/notifiers/slackNotifier.test.ts

@@ -0,0 +1,113 @@
+import {afterAll, afterEach, beforeEach, describe, expect, it, type Mock, spyOn} from "bun:test";
+import * as Sentry from "@sentry/node";
+import axios from "axios";
+
+import {sendToSlack} from "./slackNotifier";
+
+describe("sendToSlack", () => {
+  let mockAxiosPost: Mock<typeof axios.post>;
+
+  const ORIGINAL_ENV = process.env;
+
+  beforeEach(() => {
+    mockAxiosPost = spyOn(axios, "post").mockResolvedValue({status: 200} as any);
+    process.env = {...ORIGINAL_ENV};
+    process.env.SLACK_WEBHOOKS = undefined;
+    (Sentry.captureException as Mock<typeof Sentry.captureException>).mockClear();
+    (Sentry.captureMessage as Mock<typeof Sentry.captureMessage>).mockClear();
+  });
+
+  afterEach(() => {
+    mockAxiosPost.mockRestore();
+  });
+
+  afterAll(() => {
+    process.env = ORIGINAL_ENV;
+  });
+
+  it("returns early when SLACK_WEBHOOKS is missing", async () => {
+    await sendToSlack("hello");
+    expect(mockAxiosPost.mock.calls.length).toBe(0);
+  });
+
+  it("posts to default webhook with plain text", async () => {
+    process.env.SLACK_WEBHOOKS = JSON.stringify({default: "https://slack.example/webhook"});
+    mockAxiosPost.mockResolvedValue({status: 200});
+
+    await sendToSlack("hello world");
+    expect(mockAxiosPost.mock.calls.length).toBe(1);
+    const callArgs = mockAxiosPost.mock.calls[0];
+    expect(Array.isArray(callArgs)).toBe(true);
+    const [url, payload] = callArgs;
+    expect(url).toBe("https://slack.example/webhook");
+    expect(payload).toEqual({text: "hello world"});
+  });
+
+  it("posts to a specific channel when provided", async () => {
+    process.env.SLACK_WEBHOOKS = JSON.stringify({
+      default: "https://slack.example/default",
+      ops: "https://slack.example/ops",
+    });
+    mockAxiosPost.mockResolvedValue({status: 200});
+
+    await sendToSlack("ops msg", {slackChannel: "ops"});
+    const callArgs = mockAxiosPost.mock.calls[0];
+    expect(Array.isArray(callArgs)).toBe(true);
+    const [url, payload] = callArgs;
+    expect(url).toBe("https://slack.example/ops");
+    expect(payload).toEqual({text: "ops msg"});
+  });
+
+  it("falls back to default when channel not found", async () => {
+    process.env.SLACK_WEBHOOKS = JSON.stringify({
+      default: "https://slack.example/default",
+    });
+    mockAxiosPost.mockResolvedValue({status: 200});
+
+    await sendToSlack("missing channel", {slackChannel: "unknown"});
+    const callArgs = mockAxiosPost.mock.calls[0];
+    expect(Array.isArray(callArgs)).toBe(true);
+    const [url, payload] = callArgs;
+    expect(url).toBe("https://slack.example/default");
+    expect(payload).toEqual({text: "missing channel"});
+  });
+
+  it("prefixes message with [ENV] when env provided", async () => {
+    process.env.SLACK_WEBHOOKS = JSON.stringify({
+      default: "https://slack.example/default",
+    });
+    mockAxiosPost.mockResolvedValue({status: 200});
+
+    await sendToSlack("status ok", {env: "stg"});
+    const callArgs = mockAxiosPost.mock.calls[0];
+    expect(Array.isArray(callArgs)).toBe(true);
+    const [, payload] = callArgs;
+    expect(payload).toEqual({text: "[STG] status ok"});
+  });
+
+  it("captures error and throws APIError when shouldThrow=true", async () => {
+    process.env.SLACK_WEBHOOKS = JSON.stringify({
+      default: "https://slack.example/default",
+    });
+    mockAxiosPost.mockRejectedValue(new Error("slack down"));
+
+    try {
+      await sendToSlack("err", {shouldThrow: true});
+      throw new Error("Expected sendToSlack to throw APIError");
+    } catch (error) {
+      expect((error as any).name).toBe("APIError");
+      expect((error as any).title).toMatch(/Error posting to slack/i);
+    }
+    expect(mockAxiosPost.mock.calls.length).toBe(1);
+  });
+
+  it("captures error and does not throw when shouldThrow=false", async () => {
+    process.env.SLACK_WEBHOOKS = JSON.stringify({
+      default: "https://slack.example/default",
+    });
+    mockAxiosPost.mockRejectedValue(new Error("slack intermittent"));
+
+    await sendToSlack("err", {shouldThrow: false});
+    expect(mockAxiosPost.mock.calls.length).toBe(1);
+  });
+});

package/src/notifiers/slackNotifier.ts

@@ -0,0 +1,55 @@
+import * as Sentry from "@sentry/node";
+import axios from "axios";
+
+import {APIError} from "../errors";
+import {logger} from "../logger";
+// Convenience method to send data to a Slack webhook.
+export async function sendToSlack(
+  text: string,
+  {
+    slackChannel,
+    shouldThrow = false,
+    env,
+  }: {slackChannel?: string; shouldThrow?: boolean; env?: string} = {}
+) {
+  // since Slack now requires a webhook for each channel, we need to store them in the environment
+  // as an object, so we can look them up by channel name.
+  const slackWebhooksString = process.env.SLACK_WEBHOOKS;
+  if (!slackWebhooksString) {
+    logger.debug("You must set SLACK_WEBHOOKS in the environment to use sendToSlack.");
+    return;
+  }
+  const slackWebhooks = JSON.parse(slackWebhooksString ?? "{}");
+
+  const channel = slackChannel ?? "default";
+
+  const slackWebhookUrl = slackWebhooks[channel] ?? slackWebhooks.default;
+
+  if (!slackWebhookUrl) {
+    Sentry.captureException(
+      new Error(`No webhook url set in env for ${channel}. Slack message not sent`)
+    );
+    logger.debug(`No webhook url set in env for ${channel}.`);
+    return;
+  }
+
+  let formattedText = text;
+  if (env) {
+    formattedText = `[${env.toUpperCase()}] ${text}`;
+  }
+
+  try {
+    await axios.post(slackWebhookUrl, {
+      text: formattedText,
+    });
+  } catch (error: any) {
+    logger.error(`Error posting to slack: ${error.text ?? error.message}`);
+    Sentry.captureException(error);
+    if (shouldThrow) {
+      throw new APIError({
+        status: 500,
+        title: `Error posting to slack: ${error.text ?? error.message}`,
+      });
+    }
+  }
+}

package/src/notifiers/zoomNotifier.test.ts

@@ -0,0 +1,207 @@
+import {afterAll, afterEach, beforeEach, describe, expect, it, type Mock, spyOn} from "bun:test";
+import * as Sentry from "@sentry/node";
+import axios from "axios";
+
+import {sendToZoom} from "./zoomNotifier";
+
+describe("sendToZoom", () => {
+  let mockAxiosPost: Mock<typeof axios.post>;
+
+  const ORIGINAL_ENV = process.env;
+
+  beforeEach(() => {
+    mockAxiosPost = spyOn(axios, "post").mockResolvedValue({status: 200} as any);
+    process.env = {...ORIGINAL_ENV};
+    process.env.ZOOM_CHAT_WEBHOOKS = undefined;
+    (Sentry.captureException as Mock<typeof Sentry.captureException>).mockClear();
+    (Sentry.captureMessage as Mock<typeof Sentry.captureMessage>).mockClear();
+  });
+
+  afterEach(() => {
+    mockAxiosPost.mockRestore();
+  });
+
+  afterAll(() => {
+    process.env = ORIGINAL_ENV;
+  });
+
+  it("returns early when ZOOM_CHAT_WEBHOOKS is missing", async () => {
+    await sendToZoom({body: "world", header: "hello"}, {channel: "default"});
+    expect(mockAxiosPost.mock.calls.length).toBe(0);
+  });
+
+  it("posts to default webhook with rich message format and authorization header", async () => {
+    process.env.ZOOM_CHAT_WEBHOOKS = JSON.stringify({
+      default: {
+        channel: "https://zoom.example/webhook",
+        verificationToken: "test-token-123",
+      },
+    });
+    mockAxiosPost.mockResolvedValue({status: 200});
+
+    await sendToZoom({body: "world", header: "hello"}, {channel: "default"});
+    expect(mockAxiosPost.mock.calls.length).toBe(1);
+    const callArgs = mockAxiosPost.mock.calls[0];
+    expect(Array.isArray(callArgs)).toBe(true);
+    const [url, payload, options] = callArgs;
+    expect(url).toBe("https://zoom.example/webhook?format=full");
+    expect(payload).toEqual({
+      content: {
+        body: [{text: "world", type: "message"}],
+        head: {text: "hello"},
+      },
+    });
+    expect(options?.headers).toEqual({
+      Authorization: "test-token-123",
+      "Content-Type": "application/json",
+    });
+  });
+
+  it("posts to a specific channel when provided", async () => {
+    process.env.ZOOM_CHAT_WEBHOOKS = JSON.stringify({
+      default: {
+        channel: "https://zoom.example/default",
+        verificationToken: "default-token",
+      },
+      ops: {
+        channel: "https://zoom.example/ops",
+        verificationToken: "ops-token",
+      },
+    });
+    mockAxiosPost.mockResolvedValue({status: 200});
+
+    await sendToZoom({body: "ops msg", header: "ops msg"}, {channel: "ops"});
+    const callArgs = mockAxiosPost.mock.calls[0];
+    expect(Array.isArray(callArgs)).toBe(true);
+    const [url, payload, options] = callArgs;
+    expect(url).toBe("https://zoom.example/ops?format=full");
+    expect(payload).toEqual({
+      content: {
+        body: [{text: "ops msg", type: "message"}],
+        head: {text: "ops msg"},
+      },
+    });
+    expect(options?.headers?.Authorization).toBe("ops-token");
+  });
+
+  it("falls back to default when channel not found", async () => {
+    process.env.ZOOM_CHAT_WEBHOOKS = JSON.stringify({
+      default: {
+        channel: "https://zoom.example/default",
+        verificationToken: "default-token",
+      },
+    });
+    mockAxiosPost.mockResolvedValue({status: 200});
+
+    await sendToZoom({body: "missing channel", header: "missing channel"}, {channel: "unknown"});
+    const callArgs = mockAxiosPost.mock.calls[0];
+    expect(Array.isArray(callArgs)).toBe(true);
+    const [url, payload] = callArgs;
+    expect(url).toBe("https://zoom.example/default?format=full");
+    expect(payload).toEqual({
+      content: {
+        body: [{text: "missing channel", type: "message"}],
+        head: {text: "missing channel"},
+      },
+    });
+  });
+
+  it("returns early when webhook url is missing for channel", async () => {
+    process.env.ZOOM_CHAT_WEBHOOKS = JSON.stringify({
+      default: {
+        verificationToken: "default-token",
+      },
+    });
+
+    await sendToZoom({body: "no url", header: "no url"}, {channel: "default"});
+    expect(mockAxiosPost.mock.calls.length).toBe(0);
+  });
+
+  it("returns early when verification token is missing for channel", async () => {
+    process.env.ZOOM_CHAT_WEBHOOKS = JSON.stringify({
+      default: {
+        channel: "https://zoom.example/default",
+      },
+    });
+
+    await sendToZoom({body: "no token", header: "no token"}, {channel: "default"});
+    expect(mockAxiosPost.mock.calls.length).toBe(0);
+  });
+
+  it("prefixes header with [ENV] when env provided", async () => {
+    process.env.ZOOM_CHAT_WEBHOOKS = JSON.stringify({
+      default: {
+        channel: "https://zoom.example/default",
+        verificationToken: "token",
+      },
+    });
+    mockAxiosPost.mockResolvedValue({status: 200});
+
+    await sendToZoom({body: "status ok", header: "status ok"}, {channel: "default", env: "stg"});
+    const callArgs = mockAxiosPost.mock.calls[0];
+    expect(Array.isArray(callArgs)).toBe(true);
+    const [, payload] = callArgs;
+    expect(payload).toEqual({
+      content: {
+        body: [{text: "status ok", type: "message"}],
+        head: {text: "[STG] status ok"},
+      },
+    });
+  });
+
+  it("includes subheader when provided", async () => {
+    process.env.ZOOM_CHAT_WEBHOOKS = JSON.stringify({
+      default: {
+        channel: "https://zoom.example/default",
+        verificationToken: "token",
+      },
+    });
+    mockAxiosPost.mockResolvedValue({status: 200});
+
+    await sendToZoom(
+      {body: "Body text", header: "Main Header", subheader: "Subheader text"},
+      {channel: "default"}
+    );
+    const callArgs = mockAxiosPost.mock.calls[0];
+    expect(Array.isArray(callArgs)).toBe(true);
+    const [, payload] = callArgs;
+    expect(payload).toEqual({
+      content: {
+        body: [{text: "Body text", type: "message"}],
+        head: {sub_head: {text: "Subheader text"}, text: "Main Header"},
+      },
+    });
+  });
+
+  it("captures error and throws APIError when shouldThrow=true", async () => {
+    process.env.ZOOM_CHAT_WEBHOOKS = JSON.stringify({
+      default: {
+        channel: "https://zoom.example/default",
+        verificationToken: "token",
+      },
+    });
+    mockAxiosPost.mockRejectedValue(new Error("zoom down"));
+
+    try {
+      await sendToZoom({body: "err", header: "err"}, {channel: "default", shouldThrow: true});
+      throw new Error("Expected sendToZoom to throw APIError");
+    } catch (error) {
+      expect((error as any).name).toBe("APIError");
+      expect((error as any).title).toMatch(/Error posting to Zoom/i);
+    }
+    expect(mockAxiosPost.mock.calls.length).toBe(1);
+  });
+
+  it("captures error and does not throw when shouldThrow=false", async () => {
+    process.env.ZOOM_CHAT_WEBHOOKS = JSON.stringify({
+      default: {
+        channel: "https://zoom.example/default",
+        verificationToken: "token",
+      },
+    });
+    mockAxiosPost.mockRejectedValue(new Error("zoom intermittent"));
+
+    await sendToZoom({body: "err", header: "err"}, {channel: "default", shouldThrow: false});
+    expect(mockAxiosPost.mock.calls.length).toBe(1);
+  });
+});

package/src/notifiers/zoomNotifier.ts

@@ -0,0 +1,111 @@
+import * as Sentry from "@sentry/node";
+import axios from "axios";
+
+import {APIError} from "../errors";
+import {logger} from "../logger";
+
+/**
+ * Sends a rich formatted message to a Zoom chat channel via webhook.
+ *
+ * @param message - Message content with header, body, and optional subheader
+ * @param message.header - Main header text for the message
+ * @param message.body - Body text content
+ * @param message.subheader - Optional subheader text displayed below the main header
+ * @param options - Configuration options
+ * @param options.channel - The Zoom channel to post to (defaults to "default")
+ * @param options.shouldThrow - If true, throws an APIError on failure; otherwise logs and continues
+ * @param options.env - Optional environment prefix (e.g., "stg", "prod") prepended to header
+ *
+ * @remarks
+ * Requires ZOOM_CHAT_WEBHOOKS environment variable containing JSON with channel configurations:
+ * ```json
+ * {
+ *   "default": {"channel": "webhook_url", "verificationToken": "token"},
+ *   "ops": {"channel": "webhook_url", "verificationToken": "token"}
+ * }
+ * ```
+ *
+ * Falls back to "default" channel if specified channel not found.
+ * Logs errors to Sentry and logger when webhook is missing or request fails.
+ * Uses Zoom's rich message format (format=full) with structured header and body.
+ */
+export async function sendToZoom(
+  {header, body, subheader}: {header: string; body: string; subheader?: string},
+  {channel, shouldThrow = false, env}: {channel: string; shouldThrow?: boolean; env?: string}
+) {
+  const zoomWebhooksString = process.env.ZOOM_CHAT_WEBHOOKS;
+  if (!zoomWebhooksString) {
+    const msg = "ZOOM_CHAT_WEBHOOKS not set. Zoom message not sent";
+    Sentry.captureException(new Error(msg));
+    logger.error(msg);
+    return;
+  }
+  const zoomWebhooks: Record<string, {channel: string; verificationToken: string}> = JSON.parse(
+    zoomWebhooksString ?? "{}"
+  );
+
+  const zoomChannel = channel ?? "default";
+  // Use format full
+  const zoomWebhookUrl = zoomWebhooks[zoomChannel]?.channel ?? zoomWebhooks.default?.channel;
+
+  if (!zoomWebhookUrl) {
+    const msg = `No webhook url set in env for ${zoomChannel}. Zoom message not sent`;
+    Sentry.captureException(new Error(msg));
+    logger.error(msg);
+    return;
+  }
+
+  const zoomToken =
+    zoomWebhooks[zoomChannel]?.verificationToken ?? zoomWebhooks.default?.verificationToken;
+  if (!zoomToken) {
+    const msg = `No verification token set in env for ${zoomChannel}. Zoom message not sent`;
+    Sentry.captureException(new Error(msg));
+    logger.error(msg);
+    return;
+  }
+
+  // Build the message structure
+  const messageBody: {
+    head: {text: string; sub_head?: {text: string}};
+    body: Array<{type: string; text: string}>;
+  } = {
+    body: [
+      {
+        text: body,
+        type: "message",
+      },
+    ],
+    head: {
+      text: env ? `[${env.toUpperCase()}] ${header}` : header,
+    },
+  };
+
+  // Add subheader if provided
+  if (subheader) {
+    messageBody.head.sub_head = {
+      text: subheader,
+    };
+  }
+
+  try {
+    await axios.post(
+      `${zoomWebhookUrl}?format=full`,
+      {content: messageBody},
+      {
+        headers: {
+          Authorization: zoomToken,
+          "Content-Type": "application/json",
+        },
+      }
+    );
+  } catch (error: any) {
+    logger.error(`Error posting to Zoom: ${error.text ?? error.message}`);
+    Sentry.captureException(error);
+    if (shouldThrow) {
+      throw new APIError({
+        status: 500,
+        title: `Error posting to Zoom: ${error.text ?? error.message}`,
+      });
+    }
+  }
+}