npm - @lovenyberg/ove - Versions diffs - 0.7.0 → 0.9.0 - Mend

@lovenyberg/ove 0.7.0 → 0.9.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (26) hide show

package/bin/ove.ts +37 -1
package/package.json +1 -1
package/public/index.html +164 -3
package/public/metrics.html +716 -0
package/public/status.html +43 -0
package/public/trace.html +127 -0
package/src/adapters/github.test.ts +8 -0
package/src/adapters/github.ts +3 -2
package/src/adapters/http.test.ts +597 -1
package/src/adapters/http.ts +222 -3
package/src/adapters/slack.test.ts +233 -0
package/src/adapters/types.ts +1 -1
package/src/adapters/whatsapp.test.ts +102 -0
package/src/adapters/wiring.test.ts +2 -0
package/src/diagnostics.test.ts +375 -0
package/src/handlers.test.ts +553 -0
package/src/handlers.ts +46 -7
package/src/index.ts +1 -0
package/src/queue.test.ts +174 -0
package/src/queue.ts +85 -7
package/src/router.test.ts +151 -1
package/src/router.ts +95 -34
package/src/sessions.test.ts +41 -0
package/src/sessions.ts +27 -0
package/src/setup.ts +160 -1
package/src/smoke.test.ts +31 -1

package/src/adapters/http.ts CHANGED Viewed

@@ -1,7 +1,8 @@
 import { readFileSync, existsSync } from "node:fs";
 import { join, extname, resolve } from "node:path";
-import { timingSafeEqual } from "node:crypto";
-import type { EventAdapter, IncomingEvent, IncomingMessage, ChatAdapter, AdapterStatus } from "./types";
+import { timingSafeEqual, createHmac } from "node:crypto";
+import type { EventAdapter, IncomingEvent, IncomingMessage, ChatAdapter, AdapterStatus, EventSource } from "./types";
+import { parseMention } from "./github";
 import type { TraceStore } from "../trace";
 import type { TaskQueue } from "../queue";
 import type { SessionStore } from "../sessions";
@@ -21,6 +22,11 @@ function safeEqual(a: string, b: string): boolean {
   return timingSafeEqual(bufA, bufB);
 }
+function verifyGitHubSignature(secret: string, rawBody: string, signature: string): boolean {
+  const expected = "sha256=" + createHmac("sha256", secret).update(rawBody).digest("hex");
+  return safeEqual(expected, signature);
+}
 export class HttpApiAdapter implements EventAdapter {
   private port: number;
   private apiKey: string;
@@ -34,20 +40,31 @@ export class HttpApiAdapter implements EventAdapter {
   private webUiHtml: string;
   private traceUiHtml: string;
   private statusUiHtml: string;
+  private metricsUiHtml: string;
   private publicDir: string;
   private chatAdapters: ChatAdapter[] = [];
   private eventAdapters: EventAdapter[] = [];
   private startedAt?: string;
+  private githubWebhookSecret: string;
+  private botName: string;
+  private runningProcesses: Map<string, { abort: AbortController; task: any }> | null = null;
   private hostname: string;
-  constructor(port: number, apiKey: string, trace: TraceStore, queue?: TaskQueue, sessions?: SessionStore, hostname?: string) {
+  /** Register the running processes map so the cancel endpoint can abort running tasks */
+  setRunningProcesses(processes: Map<string, { abort: AbortController; task: any }>): void {
+    this.runningProcesses = processes;
+  }
+  constructor(port: number, apiKey: string, trace: TraceStore, queue?: TaskQueue, sessions?: SessionStore, hostname?: string, githubWebhookSecret?: string, botName?: string) {
     this.port = port;
     this.apiKey = apiKey;
     this.hostname = hostname || "0.0.0.0";
     this.trace = trace;
     this.queue = queue || null;
     this.sessions = sessions || null;
+    this.githubWebhookSecret = githubWebhookSecret || process.env.GITHUB_WEBHOOK_SECRET || "";
+    this.botName = botName || process.env.GITHUB_BOT_NAME || "ove";
     const publicDir = resolve(import.meta.dir, "../../public");
     this.publicDir = publicDir;
     try {
@@ -65,6 +82,11 @@ export class HttpApiAdapter implements EventAdapter {
     } catch {
       this.statusUiHtml = "<html><body><p>Status page not found. Place public/status.html in project root.</p></body></html>";
     }
+    try {
+      this.metricsUiHtml = readFileSync(join(publicDir, "metrics.html"), "utf-8");
+    } catch {
+      this.metricsUiHtml = "<html><body><p>Metrics page not found. Place public/metrics.html in project root.</p></body></html>";
+    }
   }
   /** Set the chat message handler so web UI messages go through the full chat pipeline */
@@ -119,6 +141,112 @@ export class HttpApiAdapter implements EventAdapter {
           });
         }
+        if (path === "/metrics" || path === "/metrics.html") {
+          return new Response(self.metricsUiHtml, {
+            headers: { "Content-Type": "text/html" },
+          });
+        }
+        // POST /api/webhooks/github — GitHub webhook with HMAC-SHA256 signature validation
+        if (path === "/api/webhooks/github" && req.method === "POST") {
+          if (!self.githubWebhookSecret) {
+            return Response.json({ error: "GitHub webhook secret not configured" }, { status: 500 });
+          }
+          const signature = req.headers.get("X-Hub-Signature-256");
+          if (!signature) {
+            return Response.json({ error: "Missing signature" }, { status: 401 });
+          }
+          const rawBody = await req.text();
+          if (rawBody.length > 1_048_576) {
+            return Response.json({ error: "Payload too large (max 1MB)" }, { status: 413 });
+          }
+          if (!verifyGitHubSignature(self.githubWebhookSecret, rawBody, signature)) {
+            return Response.json({ error: "Invalid signature" }, { status: 401 });
+          }
+          const githubEvent = req.headers.get("X-GitHub-Event");
+          if (githubEvent !== "issue_comment" && githubEvent !== "pull_request_review_comment") {
+            return Response.json({ ok: true, skipped: true, reason: `Unsupported event: ${githubEvent}` });
+          }
+          let payload: any;
+          try {
+            payload = JSON.parse(rawBody);
+          } catch {
+            return Response.json({ error: "Invalid JSON body" }, { status: 400 });
+          }
+          // Only process created comments
+          if (payload.action !== "created") {
+            return Response.json({ ok: true, skipped: true, reason: `Ignored action: ${payload.action}` });
+          }
+          const comment = payload.comment;
+          if (!comment?.body || !comment?.user?.login) {
+            return Response.json({ error: "Missing comment data" }, { status: 400 });
+          }
+          // Skip bot's own comments to prevent infinite loops
+          if (comment.user.login === self.botName) {
+            return Response.json({ ok: true, skipped: true, reason: "Own comment" });
+          }
+          const repoFullName = payload.repository?.full_name;
+          if (!repoFullName) {
+            return Response.json({ error: "Missing repository data" }, { status: 400 });
+          }
+          // Parse @mention — same logic as github.ts polling adapter
+          const text = parseMention(comment.body, self.botName);
+          if (!text) {
+            return Response.json({ ok: true, skipped: true, reason: "No mention found" });
+          }
+          // Determine source type and issue/PR number
+          let sourceType: "issue" | "pr";
+          let number: number;
+          if (githubEvent === "pull_request_review_comment") {
+            sourceType = "pr";
+            number = payload.pull_request?.number;
+          } else {
+            // issue_comment can be on issues or PRs
+            if (payload.issue?.pull_request) {
+              sourceType = "pr";
+            } else {
+              sourceType = "issue";
+            }
+            number = payload.issue?.number;
+          }
+          if (!number) {
+            return Response.json({ error: "Could not determine issue/PR number" }, { status: 400 });
+          }
+          const source: EventSource = { type: sourceType, repo: repoFullName, number };
+          const eventId = `github:${repoFullName}:${sourceType}:${number}`;
+          const event: IncomingEvent = {
+            eventId,
+            userId: `github:${comment.user.login}`,
+            platform: "github",
+            source,
+            text,
+          };
+          logger.info("github webhook event received", {
+            repo: repoFullName,
+            user: comment.user.login,
+            event: githubEvent,
+            number,
+          });
+          self.onEvent?.(event);
+          return Response.json({ ok: true, eventId });
+        }
         // Auth check for API routes
         if (path.startsWith("/api/")) {
           const key = req.headers.get("X-API-Key") || url.searchParams.get("key");
@@ -127,6 +255,48 @@ export class HttpApiAdapter implements EventAdapter {
           }
         }
+        // POST /api/webhooks/generic — generic webhook with API key auth
+        if (path === "/api/webhooks/generic" && req.method === "POST") {
+          let body: { repo: string; text: string; userId?: string };
+          try {
+            const rawBody = await req.text();
+            if (rawBody.length > 1_048_576) {
+              return Response.json({ error: "Payload too large (max 1MB)" }, { status: 413 });
+            }
+            body = JSON.parse(rawBody) as { repo: string; text: string; userId?: string };
+          } catch {
+            return Response.json({ error: "Invalid JSON body" }, { status: 400 });
+          }
+          if (!body || typeof body.repo !== "string" || !body.repo.trim()) {
+            return Response.json({ error: "Missing or invalid 'repo' field" }, { status: 400 });
+          }
+          if (typeof body.text !== "string" || !body.text.trim()) {
+            return Response.json({ error: "Missing or invalid 'text' field" }, { status: 400 });
+          }
+          const userId = (body.userId && typeof body.userId === "string") ? body.userId : "webhook:generic";
+          const eventId = `webhook:${crypto.randomUUID()}`;
+          const source: EventSource = { type: "http", requestId: eventId, repo: body.repo.trim() };
+          const event: IncomingEvent = {
+            eventId,
+            userId,
+            platform: "webhook",
+            source,
+            text: body.text.trim(),
+          };
+          logger.info("generic webhook event received", {
+            repo: body.repo,
+            userId,
+            textLength: body.text.length,
+          });
+          self.onEvent?.(event);
+          return Response.json({ ok: true, eventId }, { status: 202 });
+        }
         // GET /api/status — adapter health + queue stats
         if (path === "/api/status" && req.method === "GET") {
           const adapterStatuses: AdapterStatus[] = [];
@@ -145,6 +315,27 @@ export class HttpApiAdapter implements EventAdapter {
           });
         }
+        // GET /api/metrics — aggregated metrics
+        if (path === "/api/metrics" && req.method === "GET") {
+          if (!self.queue) {
+            return Response.json({ error: "Task queue not available" }, { status: 503 });
+          }
+          const adapterStatuses: AdapterStatus[] = [];
+          for (const a of self.chatAdapters) {
+            adapterStatuses.push(a.getStatus?.() ?? { name: a.constructor.name, type: "chat", status: "unknown" });
+          }
+          for (const a of self.eventAdapters) {
+            adapterStatuses.push(a.getStatus?.() ?? { name: a.constructor.name, type: "event", status: "unknown" });
+          }
+          const metrics = self.queue.metrics();
+          return Response.json({
+            ...metrics,
+            adapters: adapterStatuses,
+            uptime: process.uptime(),
+            timestamp: new Date().toISOString(),
+          });
+        }
         // GET /api/tasks — list recent tasks
         if (path === "/api/tasks" && req.method === "GET") {
           if (!self.queue) {
@@ -159,12 +350,40 @@ export class HttpApiAdapter implements EventAdapter {
             repo: t.repo,
             prompt: t.prompt,
             status: t.status,
+            priority: t.priority,
             result: t.result && t.result.length > 300 ? t.result.slice(0, 300) + "..." : t.result,
             createdAt: t.createdAt,
             completedAt: t.completedAt,
           })));
         }
+        // POST /api/tasks/:id/cancel — cancel a running or pending task
+        const cancelMatch = path.match(/^\/api\/tasks\/([^/]+)\/cancel$/);
+        if (cancelMatch && req.method === "POST") {
+          if (!self.queue) {
+            return Response.json({ error: "Task queue not available" }, { status: 503 });
+          }
+          const taskId = cancelMatch[1];
+          const task = self.queue.get(taskId);
+          if (!task) {
+            return Response.json({ error: "Task not found" }, { status: 404 });
+          }
+          if (task.status !== "running" && task.status !== "pending") {
+            return Response.json({ error: "Task is not cancellable", status: task.status }, { status: 409 });
+          }
+          // If it's running, abort the process
+          if (task.status === "running" && self.runningProcesses) {
+            const entry = self.runningProcesses.get(taskId);
+            if (entry) {
+              entry.abort.abort();
+            }
+          }
+          self.queue.cancel(taskId);
+          return Response.json({ ok: true, taskId: task.id, cancelled: true });
+        }
         // POST /api/message — submit a chat message (full chat pipeline)
         if (path === "/api/message" && req.method === "POST") {
           let body: { text: string };

package/src/adapters/slack.test.ts ADDED Viewed

@@ -0,0 +1,233 @@
+import { describe, test, expect, mock, beforeEach } from "bun:test";
+import type { IncomingMessage } from "./types";
+// Capture registered handlers so we can invoke them in tests
+let messageHandler: Function;
+let appMentionHandler: Function;
+let mockStart: ReturnType<typeof mock>;
+let mockStop: ReturnType<typeof mock>;
+let mockConversationsOpen: ReturnType<typeof mock>;
+let mockChatPostMessage: ReturnType<typeof mock>;
+let mockChatUpdate: ReturnType<typeof mock>;
+// Mock @slack/bolt before importing the adapter
+mock.module("@slack/bolt", () => ({
+  App: class FakeApp {
+    client = {
+      conversations: { open: (...args: any[]) => mockConversationsOpen(...args) },
+      chat: {
+        postMessage: (...args: any[]) => mockChatPostMessage(...args),
+        update: (...args: any[]) => mockChatUpdate(...args),
+      },
+    };
+    message(handler: Function) {
+      messageHandler = handler;
+    }
+    event(name: string, handler: Function) {
+      if (name === "app_mention") appMentionHandler = handler;
+    }
+    start() {
+      mockStart();
+      return Promise.resolve();
+    }
+    stop() {
+      mockStop();
+      return Promise.resolve();
+    }
+  },
+}));
+// Import after mocking
+const { SlackAdapter } = await import("./slack");
+describe("SlackAdapter", () => {
+  beforeEach(() => {
+    mockStart = mock(() => {});
+    mockStop = mock(() => {});
+    mockConversationsOpen = mock(() =>
+      Promise.resolve({ channel: { id: "C_DM_CHANNEL" } })
+    );
+    mockChatPostMessage = mock(() => Promise.resolve({ ok: true }));
+    mockChatUpdate = mock(() => Promise.resolve({ ok: true }));
+  });
+  test("module exports SlackAdapter class", async () => {
+    const mod = await import("./slack");
+    expect(mod.SlackAdapter).toBeDefined();
+  });
+  test("constructor creates instance without throwing", () => {
+    expect(() => new SlackAdapter()).not.toThrow();
+  });
+  test("getStatus() returns disconnected before start", () => {
+    const adapter = new SlackAdapter();
+    const status = adapter.getStatus();
+    expect(status.name).toBe("slack");
+    expect(status.type).toBe("chat");
+    expect(status.status).toBe("disconnected");
+    expect(status.startedAt).toBeUndefined();
+  });
+  test("getStatus() returns connected after start", async () => {
+    const adapter = new SlackAdapter();
+    await adapter.start(() => {});
+    const status = adapter.getStatus();
+    expect(status.status).toBe("connected");
+    expect(status.startedAt).toBeDefined();
+  });
+  test("start() registers handlers and calls app.start", async () => {
+    const adapter = new SlackAdapter();
+    await adapter.start(() => {});
+    expect(mockStart).toHaveBeenCalledTimes(1);
+    expect(messageHandler).toBeDefined();
+    expect(appMentionHandler).toBeDefined();
+  });
+  test("message handler ignores messages with subtype", async () => {
+    const received: IncomingMessage[] = [];
+    const adapter = new SlackAdapter();
+    await adapter.start((msg) => received.push(msg));
+    await messageHandler({
+      message: { subtype: "bot_message", text: "hello", user: "U123", channel: "C1" },
+      say: mock(() => Promise.resolve()),
+    });
+    expect(received).toHaveLength(0);
+  });
+  test("message handler ignores messages without text", async () => {
+    const received: IncomingMessage[] = [];
+    const adapter = new SlackAdapter();
+    await adapter.start((msg) => received.push(msg));
+    await messageHandler({
+      message: { user: "U123", channel: "C1" },
+      say: mock(() => Promise.resolve()),
+    });
+    expect(received).toHaveLength(0);
+  });
+  test("message handler ignores messages without user", async () => {
+    const received: IncomingMessage[] = [];
+    const adapter = new SlackAdapter();
+    await adapter.start((msg) => received.push(msg));
+    await messageHandler({
+      message: { text: "hello", channel: "C1" },
+      say: mock(() => Promise.resolve()),
+    });
+    expect(received).toHaveLength(0);
+  });
+  test("message handler delivers valid DM with slack: prefix on userId", async () => {
+    const received: IncomingMessage[] = [];
+    const adapter = new SlackAdapter();
+    await adapter.start((msg) => received.push(msg));
+    await messageHandler({
+      message: { text: "fix the bug", user: "U42", channel: "C1" },
+      say: mock(() => Promise.resolve()),
+    });
+    expect(received).toHaveLength(1);
+    expect(received[0].userId).toBe("slack:U42");
+    expect(received[0].platform).toBe("slack");
+    expect(received[0].text).toBe("fix the bug");
+  });
+  test("app_mention handler strips <@MENTION> tags from text", async () => {
+    const received: IncomingMessage[] = [];
+    const adapter = new SlackAdapter();
+    await adapter.start((msg) => received.push(msg));
+    await appMentionHandler({
+      event: { text: "<@U00BOT> deploy to prod", user: "U99", channel: "C2" },
+      say: mock(() => Promise.resolve()),
+    });
+    expect(received).toHaveLength(1);
+    expect(received[0].text).toBe("deploy to prod");
+    expect(received[0].userId).toBe("slack:U99");
+  });
+  test("app_mention strips multiple <@MENTION> tags", async () => {
+    const received: IncomingMessage[] = [];
+    const adapter = new SlackAdapter();
+    await adapter.start((msg) => received.push(msg));
+    await appMentionHandler({
+      event: { text: "<@U00BOT> hey <@U00OTHER> help", user: "U99", channel: "C2" },
+      say: mock(() => Promise.resolve()),
+    });
+    expect(received).toHaveLength(1);
+    expect(received[0].text).toBe("hey  help");
+  });
+  test("sendToUser strips slack: prefix and opens conversation", async () => {
+    const adapter = new SlackAdapter();
+    await adapter.start(() => {});
+    await adapter.sendToUser("slack:U42", "task done");
+    expect(mockConversationsOpen).toHaveBeenCalledWith({ users: "U42" });
+    expect(mockChatPostMessage).toHaveBeenCalledWith({
+      channel: "C_DM_CHANNEL",
+      text: "task done",
+    });
+  });
+  test("reply callback calls say", async () => {
+    const received: IncomingMessage[] = [];
+    const saySpy = mock(() => Promise.resolve());
+    const adapter = new SlackAdapter();
+    await adapter.start((msg) => received.push(msg));
+    await messageHandler({
+      message: { text: "hello", user: "U1", channel: "C1" },
+      say: saySpy,
+    });
+    expect(received).toHaveLength(1);
+    await received[0].reply("response text");
+    expect(saySpy).toHaveBeenCalledWith("response text");
+  });
+  test("updateStatus debounces calls", async () => {
+    const received: IncomingMessage[] = [];
+    const saySpy = mock(() => Promise.resolve({ ts: "1234.5678" }));
+    const adapter = new SlackAdapter();
+    await adapter.start((msg) => received.push(msg));
+    await messageHandler({
+      message: { text: "work", user: "U1", channel: "C1" },
+      say: saySpy,
+    });
+    expect(received).toHaveLength(1);
+    // Fire multiple rapid status updates - debounce should collapse them
+    received[0].updateStatus("step 1");
+    received[0].updateStatus("step 2");
+    received[0].updateStatus("step 3");
+    // say should not have been called yet (debounce delay is 3000ms)
+    // Only the initial message handler call to say happened (0 times for status)
+    // The debounce timer hasn't fired yet
+    expect(saySpy).toHaveBeenCalledTimes(0);
+  });
+  test("stop() marks adapter as disconnected", async () => {
+    const adapter = new SlackAdapter();
+    await adapter.start(() => {});
+    expect(adapter.getStatus().status).toBe("connected");
+    await adapter.stop();
+    expect(adapter.getStatus().status).toBe("disconnected");
+    expect(mockStop).toHaveBeenCalledTimes(1);
+  });
+});

package/src/adapters/types.ts CHANGED Viewed

@@ -25,7 +25,7 @@ export interface ChatAdapter {
 export type EventSource =
   | { type: "issue"; repo: string; number: number }
   | { type: "pr"; repo: string; number: number }
-  | { type: "http"; requestId: string };
+  | { type: "http"; requestId: string; repo?: string };
 export interface IncomingEvent {
   eventId: string;

package/src/adapters/whatsapp.test.ts ADDED Viewed

@@ -0,0 +1,102 @@
+import { describe, test, expect, mock } from "bun:test";
+// Mock baileys before importing the adapter
+mock.module("baileys", () => ({
+  default: () => ({
+    ev: {
+      on: () => {},
+    },
+    end: () => {},
+    sendMessage: mock(() => Promise.resolve({ key: { id: "mock-id" } })),
+  }),
+  useMultiFileAuthState: () =>
+    Promise.resolve({ state: {}, saveCreds: () => {} }),
+  DisconnectReason: { loggedOut: 401 },
+}));
+import { WhatsAppAdapter } from "./whatsapp";
+describe("WhatsAppAdapter", () => {
+  test("module exports WhatsAppAdapter class", async () => {
+    const mod = await import("./whatsapp");
+    expect(mod.WhatsAppAdapter).toBeDefined();
+  });
+  test("constructor defaults authDir to ./auth/whatsapp", () => {
+    const adapter = new WhatsAppAdapter();
+    // Access private field via getStatus details or by casting
+    const status = adapter.getStatus();
+    // authDir is private, but we can verify the object was constructed
+    expect(adapter).toBeInstanceOf(WhatsAppAdapter);
+  });
+  test("constructor defaults allowedChats to empty Set", () => {
+    const adapter = new WhatsAppAdapter();
+    // allowedChats is private; we verify construction succeeds with defaults
+    expect(adapter).toBeInstanceOf(WhatsAppAdapter);
+  });
+  test("constructor accepts custom options", () => {
+    const adapter = new WhatsAppAdapter({
+      authDir: "/custom/auth",
+      phoneNumber: "+1234567890",
+      allowedChats: ["chat1", "chat2"],
+    });
+    expect(adapter).toBeInstanceOf(WhatsAppAdapter);
+  });
+  test("getStatus() returns name and type", () => {
+    const adapter = new WhatsAppAdapter();
+    const status = adapter.getStatus();
+    expect(status.name).toBe("whatsapp");
+    expect(status.type).toBe("chat");
+  });
+  test("getStatus() returns 'unknown' before start (initial connecting state)", () => {
+    const adapter = new WhatsAppAdapter();
+    const status = adapter.getStatus();
+    // Initial connectionState is "connecting" with reconnectAttempt=0 => "unknown"
+    expect(status.status).toBe("unknown");
+  });
+  test("getStatus() includes details with reconnectAttempt and pairingCode", () => {
+    const adapter = new WhatsAppAdapter();
+    const status = adapter.getStatus();
+    expect(status.details).toBeDefined();
+    expect(status.details).toHaveProperty("reconnectAttempt", 0);
+    expect(status.details).toHaveProperty("pairingCode", undefined);
+  });
+  test("getStatus() error is undefined initially", () => {
+    const adapter = new WhatsAppAdapter();
+    const status = adapter.getStatus();
+    expect(status.error).toBeUndefined();
+  });
+  test("sendToUser() formats JID from userId", async () => {
+    const adapter = new WhatsAppAdapter();
+    // Start the adapter so sock is initialized
+    await adapter.start(() => {});
+    // sendToUser should format "whatsapp:1234" -> "1234@s.whatsapp.net"
+    // Since sock is mocked, this won't throw
+    await adapter.sendToUser("whatsapp:1234", "hello");
+    // Access the mock to verify the JID format
+    const sock = (adapter as any).sock;
+    expect(sock.sendMessage).toHaveBeenCalledWith("1234@s.whatsapp.net", {
+      text: "hello",
+    });
+  });
+  test("stop() nullifies the socket", async () => {
+    const adapter = new WhatsAppAdapter();
+    await adapter.start(() => {});
+    expect((adapter as any).sock).not.toBeNull();
+    await adapter.stop();
+    expect((adapter as any).sock).toBeNull();
+  });
+});

package/src/adapters/wiring.test.ts CHANGED Viewed

@@ -7,10 +7,12 @@ describe("adapter wiring", () => {
     const discord = await import("./discord");
     const http = await import("./http");
     const github = await import("./github");
+    const slack = await import("./slack");
     expect(telegram.TelegramAdapter).toBeDefined();
     expect(discord.DiscordAdapter).toBeDefined();
     expect(http.HttpApiAdapter).toBeDefined();
     expect(github.GitHubAdapter).toBeDefined();
+    expect(slack.SlackAdapter).toBeDefined();
   });
 });