@checkstack/integration-webex-backend 0.0.2

package/CHANGELOG.md

@@ -0,0 +1,33 @@
+# @checkstack/integration-webex-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/integration-backend@0.0.2
+
+## 0.1.0
+
+### Minor Changes
+
+- 4c5aa9e: Add Webex integration provider - sends events to Webex team spaces
+
+  - Connection schema for admin-configured Bot Token
+  - Dynamic room/space selection via Webex API
+  - Template-based message formatting with default fallback
+  - Test connection verification via /people/me endpoint
+  - Comprehensive documentation for bot setup
+
+### Patch Changes
+
+- Updated dependencies [4c5aa9e]
+- Updated dependencies [b4eb432]
+- Updated dependencies [a65e002]
+- Updated dependencies [a65e002]
+  - @checkstack/integration-backend@0.1.0
+  - @checkstack/backend-api@1.1.0
+  - @checkstack/common@0.2.0

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@checkstack/integration-webex-backend",
+  "version": "0.0.2",
+  "type": "module",
+  "main": "src/index.ts",
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "lint": "bun run lint:code",
+    "lint:code": "eslint . --max-warnings 0"
+  },
+  "dependencies": {
+    "@checkstack/backend-api": "workspace:*",
+    "@checkstack/integration-backend": "workspace:*",
+    "@checkstack/common": "workspace:*",
+    "zod": "^4.2.1"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.0.0",
+    "typescript": "^5.0.0",
+    "@checkstack/tsconfig": "workspace:*"
+  }
+}

package/src/index.ts

@@ -0,0 +1,23 @@
+import { createBackendPlugin } from "@checkstack/backend-api";
+import { providerExtensionPoint } from "@checkstack/integration-backend";
+import { pluginMetadata } from "./plugin-metadata";
+import { webexProvider } from "./provider";
+
+export default createBackendPlugin({
+  metadata: pluginMetadata,
+
+  register(env) {
+    // Get the integration provider extension point
+    const extensionPoint = env.getExtensionPoint(providerExtensionPoint);
+
+    // Register the Webex provider with our plugin metadata
+    extensionPoint.addProvider(webexProvider, pluginMetadata);
+  },
+});
+
+// Re-export for testing
+export {
+  webexProvider,
+  WebexConnectionSchema,
+  WebexSubscriptionSchema,
+} from "./provider";

package/src/plugin-metadata.ts

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

package/src/provider.test.ts

@@ -0,0 +1,373 @@
+import { describe, it, expect, beforeEach, mock, spyOn } from "bun:test";
+import {
+  webexProvider,
+  WebexConnectionSchema,
+  WebexSubscriptionSchema,
+} from "./index";
+
+/**
+ * Unit tests for the Webex Integration Provider.
+ *
+ * Tests cover:
+ * - Config schema validation
+ * - Connection testing
+ * - Room options resolution
+ * - Event delivery
+ */
+
+// Mock logger
+const mockLogger = {
+  debug: mock(() => {}),
+  info: mock(() => {}),
+  warn: mock(() => {}),
+  error: mock(() => {}),
+};
+
+describe("Webex Integration Provider", () => {
+  beforeEach(() => {
+    mockLogger.debug.mockClear();
+    mockLogger.info.mockClear();
+    mockLogger.warn.mockClear();
+    mockLogger.error.mockClear();
+  });
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // Provider Metadata
+  // ─────────────────────────────────────────────────────────────────────────
+
+  describe("metadata", () => {
+    it("has correct basic metadata", () => {
+      expect(webexProvider.id).toBe("webex");
+      expect(webexProvider.displayName).toBe("Webex");
+      expect(webexProvider.description).toContain("Webex");
+      expect(webexProvider.icon).toBe("MessageSquare");
+    });
+
+    it("has versioned config and connection schemas", () => {
+      expect(webexProvider.config).toBeDefined();
+      expect(webexProvider.config.version).toBe(1);
+      expect(webexProvider.connectionSchema).toBeDefined();
+      expect(webexProvider.connectionSchema?.version).toBe(1);
+    });
+
+    it("has documentation", () => {
+      expect(webexProvider.documentation).toBeDefined();
+      expect(webexProvider.documentation?.setupGuide).toContain("Webex Bot");
+    });
+  });
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // Config Schema Validation
+  // ─────────────────────────────────────────────────────────────────────────
+
+  describe("connection schema", () => {
+    it("requires bot token", () => {
+      expect(() => {
+        WebexConnectionSchema.parse({});
+      }).toThrow();
+    });
+
+    it("accepts valid connection config", () => {
+      const result = WebexConnectionSchema.parse({
+        botToken: "test-bot-token-abc123",
+      });
+      expect(result.botToken).toBe("test-bot-token-abc123");
+    });
+  });
+
+  describe("subscription schema", () => {
+    it("requires connectionId and roomId", () => {
+      expect(() => {
+        WebexSubscriptionSchema.parse({});
+      }).toThrow();
+
+      expect(() => {
+        WebexSubscriptionSchema.parse({ connectionId: "conn-1" });
+      }).toThrow();
+    });
+
+    it("accepts valid subscription config", () => {
+      const result = WebexSubscriptionSchema.parse({
+        connectionId: "conn-1",
+        roomId: "room-123",
+      });
+      expect(result.connectionId).toBe("conn-1");
+      expect(result.roomId).toBe("room-123");
+      expect(result.messageTemplate).toBeUndefined();
+    });
+
+    it("accepts optional message template", () => {
+      const result = WebexSubscriptionSchema.parse({
+        connectionId: "conn-1",
+        roomId: "room-123",
+        messageTemplate: "Event: {{event.eventId}}",
+      });
+      expect(result.messageTemplate).toBe("Event: {{event.eventId}}");
+    });
+  });
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // Test Connection
+  // ─────────────────────────────────────────────────────────────────────────
+
+  describe("testConnection", () => {
+    it("returns success for valid token", async () => {
+      const mockFetch = spyOn(globalThis, "fetch").mockImplementation(
+        (async () => {
+          return new Response(
+            JSON.stringify({ id: "bot-123", displayName: "Test Bot" }),
+            { status: 200 }
+          );
+        }) as unknown as typeof fetch
+      );
+
+      try {
+        const result = await webexProvider.testConnection!({
+          botToken: "valid-token",
+        });
+
+        expect(result.success).toBe(true);
+        expect(result.message).toContain("Test Bot");
+      } finally {
+        mockFetch.mockRestore();
+      }
+    });
+
+    it("returns failure for invalid token", async () => {
+      const mockFetch = spyOn(globalThis, "fetch").mockImplementation(
+        (async () => {
+          return new Response("Unauthorized", { status: 401 });
+        }) as unknown as typeof fetch
+      );
+
+      try {
+        const result = await webexProvider.testConnection!({
+          botToken: "invalid-token",
+        });
+
+        expect(result.success).toBe(false);
+        expect(result.message).toContain("failed");
+      } finally {
+        mockFetch.mockRestore();
+      }
+    });
+
+    it("returns failure for invalid config", async () => {
+      // Pass config with empty botToken - passes validation but fails API call
+      const result = await webexProvider.testConnection!({
+        botToken: "",
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.message).toContain("failed");
+    });
+  });
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // Get Connection Options
+  // ─────────────────────────────────────────────────────────────────────────
+
+  describe("getConnectionOptions", () => {
+    it("returns room options when resolver matches", async () => {
+      const mockFetch = spyOn(globalThis, "fetch").mockImplementation(
+        (async () => {
+          return new Response(
+            JSON.stringify({
+              items: [
+                { id: "room-1", title: "Engineering", type: "group" },
+                { id: "room-2", title: "DevOps", type: "group" },
+              ],
+            }),
+            { status: 200 }
+          );
+        }) as unknown as typeof fetch
+      );
+
+      try {
+        const options = await webexProvider.getConnectionOptions!({
+          resolverName: "roomOptions",
+          connectionId: "conn-1",
+          context: {},
+          logger: mockLogger,
+          getConnectionWithCredentials: async () => ({
+            config: { botToken: "test-token" },
+          }),
+        });
+
+        expect(options).toHaveLength(2);
+        expect(options[0]).toEqual({ value: "room-1", label: "Engineering" });
+        expect(options[1]).toEqual({ value: "room-2", label: "DevOps" });
+      } finally {
+        mockFetch.mockRestore();
+      }
+    });
+
+    it("returns empty array for unknown resolver", async () => {
+      const options = await webexProvider.getConnectionOptions!({
+        resolverName: "unknownResolver",
+        connectionId: "conn-1",
+        context: {},
+        logger: mockLogger,
+        getConnectionWithCredentials: async () => ({
+          config: { botToken: "test-token" },
+        }),
+      });
+
+      expect(options).toEqual([]);
+    });
+
+    it("returns empty array when connection not found", async () => {
+      const options = await webexProvider.getConnectionOptions!({
+        resolverName: "roomOptions",
+        connectionId: "conn-1",
+        context: {},
+        logger: mockLogger,
+        getConnectionWithCredentials: async () => undefined,
+      });
+
+      expect(options).toEqual([]);
+    });
+  });
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // Delivery
+  // ─────────────────────────────────────────────────────────────────────────
+
+  describe("deliver", () => {
+    it("sends message to Webex room successfully", 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-456" }), {
+          status: 200,
+        });
+      }) as unknown as typeof fetch);
+
+      try {
+        const result = await webexProvider.deliver({
+          event: {
+            eventId: "incident.created",
+            payload: { incidentId: "inc-123", title: "Server Down" },
+            timestamp: new Date().toISOString(),
+            deliveryId: "del-789",
+          },
+          subscription: {
+            id: "sub-1",
+            name: "Incident Notifications",
+          },
+          providerConfig: {
+            connectionId: "conn-1",
+            roomId: "room-123",
+          },
+          logger: mockLogger,
+          getConnectionWithCredentials: async () => ({
+            id: "conn-1",
+            config: { botToken: "test-token" },
+          }),
+        });
+
+        expect(result.success).toBe(true);
+        expect(result.externalId).toBe("msg-456");
+
+        const parsedBody = JSON.parse(capturedBody!);
+        expect(parsedBody.roomId).toBe("room-123");
+        expect(parsedBody.markdown).toContain("incident.created");
+      } finally {
+        mockFetch.mockRestore();
+      }
+    });
+
+    it("uses custom message template when provided", 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-456" }), {
+          status: 200,
+        });
+      }) as unknown as typeof fetch);
+
+      try {
+        await webexProvider.deliver({
+          event: {
+            eventId: "incident.created",
+            payload: { incidentId: "inc-123", title: "Server Down" },
+            timestamp: new Date().toISOString(),
+            deliveryId: "del-789",
+          },
+          subscription: {
+            id: "sub-1",
+            name: "Test Sub",
+          },
+          providerConfig: {
+            connectionId: "conn-1",
+            roomId: "room-123",
+            messageTemplate:
+              "🚨 **{{event.payload.title}}** - Incident {{event.payload.incidentId}}",
+          },
+          logger: mockLogger,
+          getConnectionWithCredentials: async () => ({
+            id: "conn-1",
+            config: { botToken: "test-token" },
+          }),
+        });
+
+        const parsedBody = JSON.parse(capturedBody!);
+        expect(parsedBody.markdown).toBe(
+          "🚨 **Server Down** - Incident inc-123"
+        );
+      } finally {
+        mockFetch.mockRestore();
+      }
+    });
+
+    it("returns error when connection not found", async () => {
+      const result = await webexProvider.deliver({
+        event: {
+          eventId: "test.event",
+          payload: {},
+          timestamp: new Date().toISOString(),
+          deliveryId: "del-1",
+        },
+        subscription: { id: "sub-1", name: "Test" },
+        providerConfig: {
+          connectionId: "nonexistent",
+          roomId: "room-1",
+        },
+        logger: mockLogger,
+        getConnectionWithCredentials: async () => undefined,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("not found");
+    });
+
+    it("returns error when credentials not available", async () => {
+      const result = await webexProvider.deliver({
+        event: {
+          eventId: "test.event",
+          payload: {},
+          timestamp: new Date().toISOString(),
+          deliveryId: "del-1",
+        },
+        subscription: { id: "sub-1", name: "Test" },
+        providerConfig: {
+          connectionId: "conn-1",
+          roomId: "room-1",
+        },
+        logger: mockLogger,
+        // getConnectionWithCredentials not provided
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("not available");
+    });
+  });
+});

package/src/provider.ts

@@ -0,0 +1,383 @@
+import { z } from "zod";
+import { configString, Versioned } from "@checkstack/backend-api";
+import type {
+  IntegrationProvider,
+  IntegrationDeliveryContext,
+  IntegrationDeliveryResult,
+  GetConnectionOptionsParams,
+  ConnectionOption,
+  TestConnectionResult,
+} from "@checkstack/integration-backend";
+
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// Resolver Names
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+const WEBEX_RESOLVERS = {
+  ROOM_OPTIONS: "roomOptions",
+} as const;
+
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// Configuration Schemas
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+/**
+ * Connection configuration - site-wide Webex Bot credentials.
+ */
+export const WebexConnectionSchema = z.object({
+  botToken: configString({ "x-secret": true }).describe(
+    "Webex Bot Access Token from developer.webex.com"
+  ),
+});
+
+export type WebexConnectionConfig = z.infer<typeof WebexConnectionSchema>;
+
+/**
+ * Subscription configuration - which Webex room to send events to.
+ */
+export const WebexSubscriptionSchema = z.object({
+  connectionId: configString({ "x-hidden": true }).describe("Webex connection"),
+  roomId: configString({
+    "x-options-resolver": WEBEX_RESOLVERS.ROOM_OPTIONS,
+    "x-depends-on": ["connectionId"],
+  }).describe("Target Webex Space"),
+  messageTemplate: z
+    .string()
+    .optional()
+    .describe(
+      "Message template (supports {{event.payload.*}} placeholders). Leave empty for default format."
+    ),
+});
+
+export type WebexSubscriptionConfig = z.infer<typeof WebexSubscriptionSchema>;
+
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// Webex API Client
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+const WEBEX_API_BASE = "https://webexapis.com/v1";
+
+interface WebexRoom {
+  id: string;
+  title: string;
+  type: "direct" | "group";
+}
+
+interface WebexRoomsResponse {
+  items: WebexRoom[];
+}
+
+interface WebexMeResponse {
+  id: string;
+  displayName: string;
+}
+
+interface WebexMessageResponse {
+  id: string;
+}
+
+async function fetchWebexRooms(
+  botToken: string
+): Promise<
+  { success: true; rooms: WebexRoom[] } | { success: false; error: string }
+> {
+  try {
+    const response = await fetch(`${WEBEX_API_BASE}/rooms?type=group&max=100`, {
+      headers: {
+        Authorization: `Bearer ${botToken}`,
+      },
+      signal: AbortSignal.timeout(10_000),
+    });
+
+    if (!response.ok) {
+      return { success: false, error: `Webex API error: ${response.status}` };
+    }
+
+    const data = (await response.json()) as WebexRoomsResponse;
+    return { success: true, rooms: data.items ?? [] };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return { success: false, error: message };
+  }
+}
+
+async function sendWebexMessage(params: {
+  botToken: string;
+  roomId: string;
+  markdown: string;
+}): Promise<
+  { success: true; messageId: string } | { success: false; error: string }
+> {
+  try {
+    const response = await fetch(`${WEBEX_API_BASE}/messages`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${params.botToken}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        roomId: params.roomId,
+        markdown: params.markdown,
+      }),
+      signal: AbortSignal.timeout(10_000),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      return {
+        success: false,
+        error: `Webex API error (${response.status}): ${errorText.slice(
+          0,
+          200
+        )}`,
+      };
+    }
+
+    const data = (await response.json()) as WebexMessageResponse;
+    return { success: true, messageId: data.id };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return { success: false, error: message };
+  }
+}
+
+async function testWebexConnection(
+  botToken: string
+): Promise<
+  { success: true; botName: string } | { success: false; error: string }
+> {
+  try {
+    const response = await fetch(`${WEBEX_API_BASE}/people/me`, {
+      headers: {
+        Authorization: `Bearer ${botToken}`,
+      },
+      signal: AbortSignal.timeout(10_000),
+    });
+
+    if (!response.ok) {
+      return { success: false, error: `Webex API error: ${response.status}` };
+    }
+
+    const data = (await response.json()) as WebexMeResponse;
+    return { success: true, botName: data.displayName };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return { success: false, error: message };
+  }
+}
+
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// Template Expansion
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+function expandTemplate(
+  template: string,
+  context: Record<string, unknown>
+): string {
+  return template.replaceAll(/\{\{([^}]+)\}\}/g, (_match, path: string) => {
+    const trimmedPath = path.trim();
+    const parts = trimmedPath.split(".");
+    let value: unknown = context;
+    for (const part of parts) {
+      if (value === null || value === undefined) {
+        return "";
+      }
+      value = (value as Record<string, unknown>)[part];
+    }
+    if (value === null || value === undefined) {
+      return "";
+    }
+    if (typeof value === "object") {
+      return JSON.stringify(value);
+    }
+    return String(value);
+  });
+}
+
+function buildDefaultMessage(
+  eventId: string,
+  payload: Record<string, unknown>,
+  subscriptionName: string
+): string {
+  const lines: string[] = [
+    `📢 **Integration Event**`,
+    `**Event:** ${eventId}`,
+    `**Subscription:** ${subscriptionName}`,
+    ``,
+    `**Payload:**`,
+    "```json",
+    JSON.stringify(payload, undefined, 2),
+    "```",
+  ];
+  return lines.join("\n");
+}
+
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// Provider Implementation
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+export const webexProvider: IntegrationProvider<
+  WebexSubscriptionConfig,
+  WebexConnectionConfig
+> = {
+  id: "webex",
+  displayName: "Webex",
+  description: "Send integration events to Webex team spaces",
+  icon: "MessageSquare",
+
+  config: new Versioned({
+    version: 1,
+    schema: WebexSubscriptionSchema,
+  }),
+
+  connectionSchema: new Versioned({
+    version: 1,
+    schema: WebexConnectionSchema,
+  }),
+
+  documentation: {
+    setupGuide: `
+## Create a Webex Bot
+
+1. Go to [developer.webex.com](https://developer.webex.com/) and sign in
+2. Navigate to **My Webex Apps** → **Create a New App** → **Create a Bot**
+3. Fill in the bot details and create
+4. Copy the **Bot Access Token** (shown only once)
+
+## Add Bot to Spaces
+
+1. In the Webex app, open the space where you want to receive events
+2. Click the **Add People** button
+3. Search for your bot's username and add it
+
+> **Note**: The bot must be a member of a space to send messages there.
+    `.trim(),
+  },
+
+  async getConnectionOptions(
+    params: GetConnectionOptionsParams
+  ): Promise<ConnectionOption[]> {
+    const { resolverName, connectionId, getConnectionWithCredentials } = params;
+
+    if (resolverName !== WEBEX_RESOLVERS.ROOM_OPTIONS) {
+      return [];
+    }
+
+    // Get connection credentials
+    const connection = await getConnectionWithCredentials(connectionId);
+    if (!connection) {
+      return [];
+    }
+
+    const config = connection.config as WebexConnectionConfig;
+    const result = await fetchWebexRooms(config.botToken);
+
+    if (!result.success) {
+      return [];
+    }
+
+    return result.rooms.map((room) => ({
+      value: room.id,
+      label: room.title,
+    }));
+  },
+
+  async testConnection(config: unknown): Promise<TestConnectionResult> {
+    try {
+      const parsedConfig = WebexConnectionSchema.parse(config);
+      const result = await testWebexConnection(parsedConfig.botToken);
+
+      return result.success
+        ? {
+            success: true,
+            message: `Connected as bot: ${result.botName}`,
+          }
+        : {
+            success: false,
+            message: `Connection failed: ${result.error}`,
+          };
+    } catch (error) {
+      const message =
+        error instanceof Error ? error.message : "Invalid configuration";
+      return {
+        success: false,
+        message: `Validation failed: ${message}`,
+      };
+    }
+  },
+
+  async deliver(
+    context: IntegrationDeliveryContext<WebexSubscriptionConfig>
+  ): Promise<IntegrationDeliveryResult> {
+    const { event, subscription, providerConfig, logger } = context;
+
+    // Parse and validate config
+    const config = WebexSubscriptionSchema.parse(providerConfig);
+
+    // Get connection with credentials
+    if (!context.getConnectionWithCredentials) {
+      return {
+        success: false,
+        error: "Connection credentials not available",
+      };
+    }
+
+    const connection = await context.getConnectionWithCredentials(
+      config.connectionId
+    );
+
+    if (!connection) {
+      return {
+        success: false,
+        error: `Connection not found: ${config.connectionId}`,
+      };
+    }
+
+    const connectionConfig = connection.config as WebexConnectionConfig;
+
+    // Build message
+    let markdown: string;
+    if (config.messageTemplate) {
+      const templateContext = {
+        event: {
+          eventId: event.eventId,
+          payload: event.payload,
+          timestamp: event.timestamp,
+          deliveryId: event.deliveryId,
+        },
+        subscription: {
+          id: subscription.id,
+          name: subscription.name,
+        },
+      };
+      markdown = expandTemplate(config.messageTemplate, templateContext);
+    } else {
+      markdown = buildDefaultMessage(
+        event.eventId,
+        event.payload as Record<string, unknown>,
+        subscription.name
+      );
+    }
+
+    // Send message
+    const result = await sendWebexMessage({
+      botToken: connectionConfig.botToken,
+      roomId: config.roomId,
+      markdown,
+    });
+
+    if (result.success) {
+      logger.info("Webex message sent", { messageId: result.messageId });
+      return {
+        success: true,
+        externalId: result.messageId,
+      };
+    } else {
+      logger.error("Failed to send Webex message", { error: result.error });
+      return {
+        success: false,
+        error: result.error,
+      };
+    }
+  },
+};

package/tsconfig.json

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