@checkstack/notification-teams-backend 0.0.2

package/CHANGELOG.md

@@ -0,0 +1,31 @@
+# @checkstack/notification-teams-backend
+
+## 0.0.2
+
+### Patch Changes
+
+- d20d274: Initial release of all @checkstack packages. Rebranded from Checkmate to Checkstack with new npm organization @checkstack and domain checkstack.dev.
+- Updated dependencies [d20d274]
+  - @checkstack/backend-api@0.0.2
+  - @checkstack/common@0.0.2
+  - @checkstack/notification-backend@0.0.2
+
+## 0.1.0
+
+### Minor Changes
+
+- 4c5aa9e: Add Microsoft Teams notification strategy - sends alerts to users via OAuth/Graph API
+
+  - Admin configures Azure AD app credentials (Tenant ID, Client ID, Client Secret)
+  - Users link their Microsoft account via OAuth flow
+  - Messages sent as Adaptive Cards to 1:1 chats via Graph API
+  - Supports importance-based coloring and action buttons
+  - Includes detailed admin setup instructions for Azure AD configuration
+
+### Patch Changes
+
+- Updated dependencies [b4eb432]
+- Updated dependencies [a65e002]
+  - @checkstack/backend-api@1.1.0
+  - @checkstack/notification-backend@0.1.2
+  - @checkstack/common@0.2.0

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@checkstack/notification-teams-backend",
+  "version": "0.0.2",
+  "type": "module",
+  "main": "src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./plugin-metadata": "./src/plugin-metadata.ts"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src --ext .ts"
+  },
+  "dependencies": {
+    "@checkstack/backend-api": "workspace:*",
+    "@checkstack/common": "workspace:*",
+    "@checkstack/notification-backend": "workspace:*",
+    "zod": "^4.2.1"
+  },
+  "devDependencies": {
+    "@checkstack/tsconfig": "workspace:*",
+    "typescript": "^5.7.2"
+  }
+}

package/src/index.test.ts

@@ -0,0 +1,298 @@
+import { describe, it, expect, beforeEach, mock, spyOn } from "bun:test";
+import { teamsConfigSchemaV1, buildAdaptiveCard } from "./index";
+import type { AdaptiveCardOptions } from "./index";
+
+/**
+ * Unit tests for the Microsoft Teams Notification Strategy.
+ *
+ * Tests cover:
+ * - Config schema validation
+ * - Adaptive Card building
+ * - Message formatting
+ */
+
+describe("Microsoft Teams Notification Strategy", () => {
+  // ─────────────────────────────────────────────────────────────────────────
+  // Config Schema Validation
+  // ─────────────────────────────────────────────────────────────────────────
+
+  describe("config schema", () => {
+    it("validates admin config - requires all fields", () => {
+      // Missing all fields should fail
+      expect(() => {
+        teamsConfigSchemaV1.parse({});
+      }).toThrow();
+
+      // Missing clientSecret should fail
+      expect(() => {
+        teamsConfigSchemaV1.parse({
+          tenantId: "test-tenant",
+          clientId: "test-client",
+        });
+      }).toThrow();
+    });
+
+    it("accepts valid config", () => {
+      const result = teamsConfigSchemaV1.parse({
+        tenantId: "12345678-1234-1234-1234-123456789abc",
+        clientId: "87654321-4321-4321-4321-cba987654321",
+        clientSecret: "super-secret-value",
+      });
+
+      expect(result.tenantId).toBe("12345678-1234-1234-1234-123456789abc");
+      expect(result.clientId).toBe("87654321-4321-4321-4321-cba987654321");
+      expect(result.clientSecret).toBe("super-secret-value");
+    });
+  });
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // Adaptive Card Building
+  // ─────────────────────────────────────────────────────────────────────────
+
+  describe("adaptive card builder", () => {
+    it("builds card with title only", () => {
+      const card = buildAdaptiveCard({
+        title: "Test Alert",
+        importance: "info",
+      }) as Record<string, unknown>;
+
+      expect(card.type).toBe("AdaptiveCard");
+      expect(card.version).toBe("1.4");
+      expect(card.$schema).toBe(
+        "http://adaptivecards.io/schemas/adaptive-card.json"
+      );
+
+      const body = card.body as Array<Record<string, unknown>>;
+      expect(body).toHaveLength(1);
+      expect(body[0].text).toContain("Test Alert");
+      expect(body[0].text).toContain("ℹ️");
+    });
+
+    it("builds card with title and body", () => {
+      const card = buildAdaptiveCard({
+        title: "System Alert",
+        body: "The system has recovered from an outage.",
+        importance: "warning",
+      }) as Record<string, unknown>;
+
+      const body = card.body as Array<Record<string, unknown>>;
+      expect(body).toHaveLength(2);
+      expect(body[0].text).toContain("⚠️");
+      expect(body[0].text).toContain("System Alert");
+      expect(body[1].text).toBe("The system has recovered from an outage.");
+    });
+
+    it("builds card with action button", () => {
+      const card = buildAdaptiveCard({
+        title: "Incident Created",
+        body: "A new incident requires your attention.",
+        importance: "critical",
+        action: {
+          label: "View Incident",
+          url: "https://example.com/incident/123",
+        },
+      }) as Record<string, unknown>;
+
+      const body = card.body as Array<Record<string, unknown>>;
+      expect(body[0].text).toContain("🚨");
+
+      const actions = card.actions as Array<Record<string, unknown>>;
+      expect(actions).toHaveLength(1);
+      expect(actions[0].type).toBe("Action.OpenUrl");
+      expect(actions[0].title).toBe("View Incident");
+      expect(actions[0].url).toBe("https://example.com/incident/123");
+    });
+
+    it("uses correct colors for importance levels", () => {
+      const infoCard = buildAdaptiveCard({
+        title: "Info",
+        importance: "info",
+      }) as Record<string, unknown>;
+      const warningCard = buildAdaptiveCard({
+        title: "Warning",
+        importance: "warning",
+      }) as Record<string, unknown>;
+      const criticalCard = buildAdaptiveCard({
+        title: "Critical",
+        importance: "critical",
+      }) as Record<string, unknown>;
+
+      const infoBody = infoCard.body as Array<Record<string, unknown>>;
+      const warningBody = warningCard.body as Array<Record<string, unknown>>;
+      const criticalBody = criticalCard.body as Array<Record<string, unknown>>;
+
+      expect(infoBody[0].color).toBe("accent");
+      expect(warningBody[0].color).toBe("warning");
+      expect(criticalBody[0].color).toBe("attention");
+    });
+  });
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // Graph API Interaction
+  // ─────────────────────────────────────────────────────────────────────────
+
+  describe("Graph API interaction", () => {
+    it("creates chat with correct member binding", async () => {
+      let capturedBody: string | undefined;
+      let capturedUrl: string | undefined;
+
+      const mockFetch = spyOn(globalThis, "fetch").mockImplementation((async (
+        url: RequestInfo | URL,
+        options?: RequestInit
+      ) => {
+        capturedUrl = url.toString();
+        capturedBody = options?.body as string;
+        return new Response(JSON.stringify({ id: "chat-123" }), {
+          status: 200,
+        });
+      }) as unknown as typeof fetch);
+
+      try {
+        const userId = "user-456";
+        const response = await fetch("https://graph.microsoft.com/v1.0/chats", {
+          method: "POST",
+          headers: {
+            Authorization: "Bearer test-token",
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({
+            chatType: "oneOnOne",
+            members: [
+              {
+                "@odata.type": "#microsoft.graph.aadUserConversationMember",
+                roles: ["owner"],
+                "user@odata.bind": `https://graph.microsoft.com/v1.0/users('${userId}')`,
+              },
+            ],
+          }),
+        });
+
+        expect(capturedUrl).toBe("https://graph.microsoft.com/v1.0/chats");
+
+        const parsedBody = JSON.parse(capturedBody!);
+        expect(parsedBody.chatType).toBe("oneOnOne");
+        expect(parsedBody.members).toHaveLength(1);
+        expect(parsedBody.members[0]["user@odata.bind"]).toContain(userId);
+
+        const result = await response.json();
+        expect(result.id).toBe("chat-123");
+      } finally {
+        mockFetch.mockRestore();
+      }
+    });
+
+    it("sends message with adaptive card attachment", async () => {
+      let capturedBody: string | undefined;
+
+      const mockFetch = spyOn(globalThis, "fetch").mockImplementation((async (
+        _url: RequestInfo | URL,
+        options?: RequestInit
+      ) => {
+        capturedBody = options?.body as string;
+        return new Response(JSON.stringify({ id: "msg-789" }), {
+          status: 200,
+        });
+      }) as unknown as typeof fetch);
+
+      try {
+        const chatId = "chat-123";
+        const adaptiveCard = buildAdaptiveCard({
+          title: "Test",
+          importance: "info",
+        });
+
+        await fetch(
+          `https://graph.microsoft.com/v1.0/chats/${chatId}/messages`,
+          {
+            method: "POST",
+            headers: {
+              Authorization: "Bearer test-token",
+              "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+              body: {
+                contentType: "html",
+                content: `<attachment id="adaptiveCard"></attachment>`,
+              },
+              attachments: [
+                {
+                  id: "adaptiveCard",
+                  contentType: "application/vnd.microsoft.card.adaptive",
+                  content: JSON.stringify(adaptiveCard),
+                },
+              ],
+            }),
+          }
+        );
+
+        const parsedBody = JSON.parse(capturedBody!);
+        expect(parsedBody.body.contentType).toBe("html");
+        expect(parsedBody.attachments).toHaveLength(1);
+        expect(parsedBody.attachments[0].contentType).toBe(
+          "application/vnd.microsoft.card.adaptive"
+        );
+
+        const cardContent = JSON.parse(parsedBody.attachments[0].content);
+        expect(cardContent.type).toBe("AdaptiveCard");
+      } finally {
+        mockFetch.mockRestore();
+      }
+    });
+
+    it("handles API errors gracefully", async () => {
+      const mockFetch = spyOn(globalThis, "fetch").mockImplementation(
+        (async () => {
+          return new Response(
+            JSON.stringify({
+              error: { code: "Forbidden", message: "Access denied" },
+            }),
+            { status: 403 }
+          );
+        }) as unknown as typeof fetch
+      );
+
+      try {
+        const response = await fetch("https://graph.microsoft.com/v1.0/chats", {
+          method: "POST",
+          headers: {
+            Authorization: "Bearer invalid-token",
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({ chatType: "oneOnOne", members: [] }),
+        });
+
+        expect(response.ok).toBe(false);
+        expect(response.status).toBe(403);
+      } finally {
+        mockFetch.mockRestore();
+      }
+    });
+  });
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // OAuth URL Building
+  // ─────────────────────────────────────────────────────────────────────────
+
+  describe("OAuth URLs", () => {
+    it("builds correct authorization URL format", () => {
+      const tenantId = "12345678-1234-1234-1234-123456789abc";
+      const expectedAuthUrl = `https://login.microsoftonline.com/${tenantId}/oauth2/v2.0/authorize`;
+      const expectedTokenUrl = `https://login.microsoftonline.com/${tenantId}/oauth2/v2.0/token`;
+
+      expect(expectedAuthUrl).toContain("login.microsoftonline.com");
+      expect(expectedAuthUrl).toContain(tenantId);
+      expect(expectedAuthUrl).toContain("oauth2/v2.0/authorize");
+
+      expect(expectedTokenUrl).toContain("login.microsoftonline.com");
+      expect(expectedTokenUrl).toContain("oauth2/v2.0/token");
+    });
+
+    it("uses correct scopes for Teams messaging", () => {
+      const requiredScopes = ["Chat.ReadWrite", "User.Read", "offline_access"];
+
+      expect(requiredScopes).toContain("Chat.ReadWrite");
+      expect(requiredScopes).toContain("User.Read");
+      expect(requiredScopes).toContain("offline_access");
+    });
+  });
+});

package/src/index.ts

@@ -0,0 +1,379 @@
+import { z } from "zod";
+import {
+  createBackendPlugin,
+  configString,
+  Versioned,
+  type NotificationStrategy,
+  type NotificationSendContext,
+  type NotificationDeliveryResult,
+  type StrategyOAuthConfig,
+} from "@checkstack/backend-api";
+import { notificationStrategyExtensionPoint } from "@checkstack/notification-backend";
+import { pluginMetadata } from "./plugin-metadata";
+
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// Configuration Schemas
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+/**
+ * Admin configuration for Microsoft Teams strategy.
+ * Uses Azure AD App for OAuth authentication.
+ */
+const teamsConfigSchemaV1 = z.object({
+  tenantId: configString({}).describe("Azure AD Tenant ID"),
+  clientId: configString({}).describe("Azure AD Application (Client) ID"),
+  clientSecret: configString({ "x-secret": true }).describe(
+    "Azure AD Client Secret"
+  ),
+});
+
+type TeamsConfig = z.infer<typeof teamsConfigSchemaV1>;
+
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// Instructions
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+const adminInstructions = `
+## Register an Azure AD Application
+
+1. Go to [Azure Portal](https://portal.azure.com/) → **Microsoft Entra ID** (formerly Azure AD)
+2. Navigate to **App registrations** → **New registration**
+3. Fill in the application details:
+   - **Name**: Your notification bot name (e.g., "Checkstack Alerts")
+   - **Supported account types**: Choose based on your tenant requirements
+   - **Redirect URI**: Select "Web" and enter: \`{YOUR_BASE_URL}/api/notification/oauth/callback/teams\`
+4. Click **Register**
+
+## Configure API Permissions
+
+1. In your app registration, go to **API permissions**
+2. Click **Add a permission** → **Microsoft Graph** → **Delegated permissions**
+3. Add these permissions:
+   - \`Chat.ReadWrite\` (to create and send to 1:1 chats)
+   - \`User.Read\` (to get user information)
+   - \`offline_access\` (for refresh tokens)
+4. Click **Grant admin consent** if required by your organization
+
+## Create Client Secret
+
+1. Go to **Certificates & secrets** → **Client secrets** → **New client secret**
+2. Enter a description and choose an expiration period
+3. Click **Add** and copy the secret value immediately (it won't be shown again)
+
+## Enter Credentials
+
+Copy the following values from your app registration:
+- **Tenant ID**: Found in **Overview** → **Directory (tenant) ID**
+- **Client ID**: Found in **Overview** → **Application (client) ID**
+- **Client Secret**: The value you just created
+`.trim();
+
+const userInstructions = `
+## Connect Your Microsoft Account
+
+1. Click the **Connect** button below
+2. Sign in with your Microsoft work or school account
+3. Review and accept the requested permissions
+4. You'll be redirected back automatically
+
+Once connected, you'll receive notifications as personal chat messages from the Checkstack bot in Microsoft Teams.
+
+> **Note**: Make sure you're signed into the correct Microsoft account that has access to Microsoft Teams.
+`.trim();
+
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// Microsoft Graph API Constants
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+const GRAPH_API_BASE = "https://graph.microsoft.com/v1.0";
+
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// Adaptive Card Builder
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+interface AdaptiveCardOptions {
+  title: string;
+  body?: string;
+  importance: "info" | "warning" | "critical";
+  action?: { label: string; url: string };
+}
+
+function buildAdaptiveCard(options: AdaptiveCardOptions): object {
+  const { title, body, importance, action } = options;
+
+  const importanceColors: Record<string, string> = {
+    info: "accent",
+    warning: "warning",
+    critical: "attention",
+  };
+
+  const importanceEmoji: Record<string, string> = {
+    info: "ℹ️",
+    warning: "⚠️",
+    critical: "🚨",
+  };
+
+  const bodyElements: object[] = [
+    {
+      type: "TextBlock",
+      text: `${importanceEmoji[importance]} ${title}`,
+      weight: "bolder",
+      size: "large",
+      wrap: true,
+      color: importanceColors[importance],
+    },
+  ];
+
+  if (body) {
+    bodyElements.push({
+      type: "TextBlock",
+      text: body,
+      wrap: true,
+    });
+  }
+
+  const card: Record<string, unknown> = {
+    type: "AdaptiveCard",
+    $schema: "http://adaptivecards.io/schemas/adaptive-card.json",
+    version: "1.4",
+    body: bodyElements,
+  };
+
+  if (action?.url) {
+    card.actions = [
+      {
+        type: "Action.OpenUrl",
+        title: action.label,
+        url: action.url,
+      },
+    ];
+  }
+
+  return card;
+}
+
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// Teams Strategy Implementation
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+/**
+ * Microsoft Teams notification strategy.
+ * Sends notifications as personal chat messages via Microsoft Graph API.
+ */
+const teamsStrategy: NotificationStrategy<TeamsConfig> = {
+  id: "teams",
+  displayName: "Microsoft Teams",
+  description: "Send notifications via Microsoft Teams personal chat",
+  icon: "MessageSquareMore",
+
+  config: new Versioned({
+    version: 1,
+    schema: teamsConfigSchemaV1,
+  }),
+
+  // OAuth-based resolution - users authenticate via Microsoft
+  contactResolution: { type: "oauth-link" },
+
+  adminInstructions,
+  userInstructions,
+
+  // OAuth configuration for Microsoft identity platform
+  // All functions receive the strategy config - no module-scoped variables needed
+  oauth: {
+    clientId: (config) => config.clientId ?? "",
+    clientSecret: (config) => config.clientSecret ?? "",
+    scopes: ["Chat.ReadWrite", "User.Read", "offline_access"],
+    authorizationUrl: (config) => {
+      // "common" works for multi-tenant Azure AD apps
+      const tenantId = config.tenantId ?? "common";
+      return `https://login.microsoftonline.com/${tenantId}/oauth2/v2.0/authorize`;
+    },
+    tokenUrl: (config) => {
+      const tenantId = config.tenantId ?? "common";
+      return `https://login.microsoftonline.com/${tenantId}/oauth2/v2.0/token`;
+    },
+    extractExternalId: (response: Record<string, unknown>) => {
+      // Microsoft returns user info we need to extract from Graph API
+      // The ID token contains the user's object ID
+      const idTokenClaims = response.id_token as string | undefined;
+      if (idTokenClaims) {
+        try {
+          // Decode JWT payload (base64url)
+          const parts = idTokenClaims.split(".");
+          if (parts.length === 3) {
+            const payload = JSON.parse(
+              Buffer.from(parts[1], "base64url").toString()
+            ) as { oid?: string };
+            if (payload.oid) {
+              return payload.oid;
+            }
+          }
+        } catch {
+          // Fall through to use sub claim
+        }
+      }
+      // Fallback to access token parsing or sub claim
+      const sub = response.sub as string | undefined;
+      return sub ?? "";
+    },
+    extractAccessToken: (response: Record<string, unknown>) =>
+      response.access_token as string,
+    extractRefreshToken: (response: Record<string, unknown>) =>
+      response.refresh_token as string | undefined,
+    extractExpiresIn: (response: Record<string, unknown>) =>
+      response.expires_in as number | undefined,
+  } satisfies StrategyOAuthConfig<TeamsConfig>,
+
+  async send(
+    context: NotificationSendContext<TeamsConfig>
+  ): Promise<NotificationDeliveryResult> {
+    const { notification, strategyConfig, logger } = context;
+
+    if (!strategyConfig.clientId || !strategyConfig.clientSecret) {
+      return {
+        success: false,
+        error: "Microsoft Teams OAuth not configured",
+      };
+    }
+
+    // Get the user's access token from context (provided by OAuth system)
+    const oauthContext = context as unknown as {
+      accessToken?: string;
+      externalId?: string;
+    };
+
+    if (!oauthContext.accessToken) {
+      return {
+        success: false,
+        error: "User has not connected their Microsoft account",
+      };
+    }
+
+    if (!oauthContext.externalId) {
+      return {
+        success: false,
+        error: "Could not determine user's Microsoft ID",
+      };
+    }
+
+    try {
+      // Step 1: Create or get the 1:1 chat with the user
+      const chatResponse = await fetch(`${GRAPH_API_BASE}/chats`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${oauthContext.accessToken}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          chatType: "oneOnOne",
+          members: [
+            {
+              "@odata.type": "#microsoft.graph.aadUserConversationMember",
+              roles: ["owner"],
+              "user@odata.bind": `https://graph.microsoft.com/v1.0/users('${oauthContext.externalId}')`,
+            },
+          ],
+        }),
+        signal: AbortSignal.timeout(10_000),
+      });
+
+      if (!chatResponse.ok) {
+        const errorText = await chatResponse.text();
+        logger.error("Failed to create/get Teams chat", {
+          status: chatResponse.status,
+          error: errorText.slice(0, 500),
+        });
+        return {
+          success: false,
+          error: `Failed to create Teams chat: ${chatResponse.status}`,
+        };
+      }
+
+      const chatData = (await chatResponse.json()) as { id: string };
+      const chatId = chatData.id;
+
+      // Step 2: Build adaptive card for the message
+      const card = buildAdaptiveCard({
+        title: notification.title,
+        body: notification.body,
+        importance: notification.importance,
+        action: notification.action,
+      });
+
+      // Step 3: Send message to the chat
+      const messageResponse = await fetch(
+        `${GRAPH_API_BASE}/chats/${chatId}/messages`,
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${oauthContext.accessToken}`,
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({
+            body: {
+              contentType: "html",
+              content: `<attachment id="adaptiveCard"></attachment>`,
+            },
+            attachments: [
+              {
+                id: "adaptiveCard",
+                contentType: "application/vnd.microsoft.card.adaptive",
+                content: JSON.stringify(card),
+              },
+            ],
+          }),
+          signal: AbortSignal.timeout(10_000),
+        }
+      );
+
+      if (!messageResponse.ok) {
+        const errorText = await messageResponse.text();
+        logger.error("Failed to send Teams message", {
+          status: messageResponse.status,
+          error: errorText.slice(0, 500),
+        });
+        return {
+          success: false,
+          error: `Failed to send Teams message: ${messageResponse.status}`,
+        };
+      }
+
+      const messageData = (await messageResponse.json()) as { id: string };
+
+      return {
+        success: true,
+        externalId: messageData.id,
+      };
+    } catch (error) {
+      const message =
+        error instanceof Error ? error.message : "Unknown Graph API error";
+      logger.error("Teams notification error", { error: message });
+      return {
+        success: false,
+        error: `Failed to send Teams notification: ${message}`,
+      };
+    }
+  },
+};
+
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// Plugin Definition
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+export default createBackendPlugin({
+  metadata: pluginMetadata,
+
+  register(env) {
+    // Get the notification strategy extension point
+    const extensionPoint = env.getExtensionPoint(
+      notificationStrategyExtensionPoint
+    );
+
+    // Register the Teams strategy with our plugin metadata
+    extensionPoint.addStrategy(teamsStrategy, pluginMetadata);
+  },
+});
+
+// Export for testing
+export { teamsConfigSchemaV1, buildAdaptiveCard };
+export type { TeamsConfig, AdaptiveCardOptions };

package/src/plugin-metadata.ts

@@ -0,0 +1,5 @@
+import type { PluginMetadata } from "@checkstack/common";
+
+export const pluginMetadata: PluginMetadata = {
+  pluginId: "notification-teams",
+};

package/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "@checkstack/tsconfig/backend.json"
+}