@kodelyth/twitch 2026.5.39 → 2026.5.42

package/src/send.test.ts

@@ -0,0 +1,342 @@
+/**
+ * Tests for send.ts module
+ *
+ * Tests cover:
+ * - Message sending with valid configuration
+ * - Account resolution and validation
+ * - Channel normalization
+ * - Markdown stripping
+ * - Error handling for missing/invalid accounts
+ * - Registry integration
+ */
+
+import { describe, expect, it, vi } from "vitest";
+import { getClientManager } from "./client-manager-registry.js";
+import { resolveTwitchAccountContext } from "./config.js";
+import { sendMessageTwitchInternal } from "./send.js";
+import {
+  BASE_TWITCH_TEST_ACCOUNT,
+  installTwitchTestHooks,
+  makeTwitchTestConfig,
+} from "./test-fixtures.js";
+import { stripMarkdownForTwitch } from "./utils/markdown.js";
+
+// Mock dependencies
+vi.mock("./config.js", () => ({
+  DEFAULT_ACCOUNT_ID: "default",
+  resolveTwitchAccountContext: vi.fn(),
+}));
+
+vi.mock("./utils/twitch.js", () => ({
+  generateMessageId: vi.fn(() => "test-msg-id"),
+  normalizeTwitchChannel: (channel: string) => channel.toLowerCase().replace(/^#/, ""),
+}));
+
+vi.mock("./utils/markdown.js", () => ({
+  stripMarkdownForTwitch: vi.fn((text: string) => text.replace(/\*\*/g, "")),
+}));
+
+vi.mock("./client-manager-registry.js", () => ({
+  getClientManager: vi.fn(),
+}));
+
+describe("send", () => {
+  const mockLogger = {
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    debug: vi.fn(),
+  };
+
+  const mockAccount = {
+    ...BASE_TWITCH_TEST_ACCOUNT,
+    accessToken: "test123",
+  };
+
+  const mockConfig = makeTwitchTestConfig(mockAccount);
+  installTwitchTestHooks();
+
+  describe("sendMessageTwitchInternal", () => {
+    function setupAccountContext(params?: {
+      account?: typeof mockAccount | null;
+      configured?: boolean;
+      availableAccountIds?: string[];
+    }) {
+      const account = params?.account === undefined ? mockAccount : params.account;
+      vi.mocked(resolveTwitchAccountContext).mockImplementation((_cfg, accountId) => ({
+        accountId: accountId?.trim() || "default",
+        account,
+        tokenResolution: { source: "config", token: account?.accessToken ?? "" },
+        configured: account ? (params?.configured ?? true) : false,
+        availableAccountIds: params?.availableAccountIds ?? ["default"],
+      }));
+    }
+
+    async function mockSuccessfulSend(params: {
+      messageId: string;
+      stripMarkdown?: (text: string) => string;
+    }) {
+      setupAccountContext();
+      vi.mocked(getClientManager).mockReturnValue({
+        sendMessage: vi.fn().mockResolvedValue({
+          ok: true,
+          messageId: params.messageId,
+        }),
+      } as unknown as ReturnType<typeof getClientManager>);
+      vi.mocked(stripMarkdownForTwitch).mockImplementation(
+        params.stripMarkdown ?? ((text) => text),
+      );
+
+      return { stripMarkdownForTwitch };
+    }
+
+    it("should send a message successfully", async () => {
+      await mockSuccessfulSend({ messageId: "twitch-msg-123" });
+
+      const result = await sendMessageTwitchInternal(
+        "#testchannel",
+        "Hello Twitch!",
+        mockConfig,
+        "default",
+        false,
+        mockLogger as unknown as Console,
+      );
+
+      expect(result.ok).toBe(true);
+      expect(result.messageId).toBe("twitch-msg-123");
+      expect(typeof result.receipt.sentAt).toBe("number");
+      expect({ ...result.receipt, sentAt: 0 }).toEqual({
+        primaryPlatformMessageId: "twitch-msg-123",
+        platformMessageIds: ["twitch-msg-123"],
+        parts: [
+          {
+            platformMessageId: "twitch-msg-123",
+            kind: "text",
+            index: 0,
+            raw: {
+              channel: "twitch",
+              conversationId: "testchannel",
+              messageId: "twitch-msg-123",
+            },
+          },
+        ],
+        raw: [
+          {
+            channel: "twitch",
+            conversationId: "testchannel",
+            messageId: "twitch-msg-123",
+          },
+        ],
+        sentAt: 0,
+      });
+    });
+
+    it("should strip markdown when enabled", async () => {
+      const { stripMarkdownForTwitch } = await mockSuccessfulSend({
+        messageId: "twitch-msg-456",
+        stripMarkdown: (text) => text.replace(/\*\*/g, ""),
+      });
+
+      await sendMessageTwitchInternal(
+        "#testchannel",
+        "**Bold** text",
+        mockConfig,
+        "default",
+        true,
+        mockLogger as unknown as Console,
+      );
+
+      expect(stripMarkdownForTwitch).toHaveBeenCalledWith("**Bold** text");
+    });
+
+    it("should return error when account not found", async () => {
+      setupAccountContext({ account: null });
+
+      const result = await sendMessageTwitchInternal(
+        "#testchannel",
+        "Hello!",
+        mockConfig,
+        "nonexistent",
+        false,
+        mockLogger as unknown as Console,
+      );
+
+      expect(result.ok).toBe(false);
+      expect(result.error).toContain("Account not found: nonexistent");
+    });
+
+    it("should return error when account not configured", async () => {
+      setupAccountContext({ configured: false });
+
+      const result = await sendMessageTwitchInternal(
+        "#testchannel",
+        "Hello!",
+        mockConfig,
+        "default",
+        false,
+        mockLogger as unknown as Console,
+      );
+
+      expect(result.ok).toBe(false);
+      expect(result.error).toContain("not properly configured");
+    });
+
+    it("should return error when no channel specified", async () => {
+      // Set channel to undefined to trigger the error (bypassing type check)
+      const accountWithoutChannel = {
+        ...mockAccount,
+        channel: undefined as unknown as string,
+      };
+      setupAccountContext({ account: accountWithoutChannel });
+
+      const result = await sendMessageTwitchInternal(
+        "",
+        "Hello!",
+        mockConfig,
+        "default",
+        false,
+        mockLogger as unknown as Console,
+      );
+
+      expect(result.ok).toBe(false);
+      expect(result.error).toContain("No channel specified");
+    });
+
+    it("should skip sending empty message after markdown stripping", async () => {
+      setupAccountContext();
+      vi.mocked(stripMarkdownForTwitch).mockReturnValue("");
+
+      const result = await sendMessageTwitchInternal(
+        "#testchannel",
+        "**Only markdown**",
+        mockConfig,
+        "default",
+        true,
+        mockLogger as unknown as Console,
+      );
+
+      expect(result.ok).toBe(true);
+      expect(result.messageId).toBe("skipped");
+      expect(result.receipt.platformMessageIds).toStrictEqual([]);
+      expect(result.receipt.parts).toStrictEqual([]);
+    });
+
+    it("should return error when client manager not found", async () => {
+      setupAccountContext();
+      vi.mocked(getClientManager).mockReturnValue(undefined);
+
+      const result = await sendMessageTwitchInternal(
+        "#testchannel",
+        "Hello!",
+        mockConfig,
+        "default",
+        false,
+        mockLogger as unknown as Console,
+      );
+
+      expect(result.ok).toBe(false);
+      expect(result.error).toContain("Client manager not found");
+    });
+
+    it("should handle send errors gracefully", async () => {
+      setupAccountContext();
+      vi.mocked(getClientManager).mockReturnValue({
+        sendMessage: vi.fn().mockRejectedValue(new Error("Connection lost")),
+      } as unknown as ReturnType<typeof getClientManager>);
+
+      const result = await sendMessageTwitchInternal(
+        "#testchannel",
+        "Hello!",
+        mockConfig,
+        "default",
+        false,
+        mockLogger as unknown as Console,
+      );
+
+      expect(result.ok).toBe(false);
+      expect(result.error).toBe("Connection lost");
+      expect(mockLogger.error).toHaveBeenCalled();
+    });
+
+    it("should use account channel when channel parameter is empty", async () => {
+      setupAccountContext();
+      const mockSend = vi.fn().mockResolvedValue({
+        ok: true,
+        messageId: "twitch-msg-789",
+      });
+      vi.mocked(getClientManager).mockReturnValue({
+        sendMessage: mockSend,
+      } as unknown as ReturnType<typeof getClientManager>);
+
+      await sendMessageTwitchInternal(
+        "",
+        "Hello!",
+        mockConfig,
+        "default",
+        false,
+        mockLogger as unknown as Console,
+      );
+
+      expect(mockSend).toHaveBeenCalledWith(
+        mockAccount,
+        "testchannel", // normalized account channel
+        "Hello!",
+        mockConfig,
+        "default",
+      );
+    });
+
+    it("uses the configured default account when accountId is omitted", async () => {
+      const secondaryAccount = {
+        ...mockAccount,
+        username: "secondary-user",
+        channel: "secondary-channel",
+      };
+      vi.mocked(resolveTwitchAccountContext).mockImplementation((_cfg, accountId) => ({
+        accountId: accountId?.trim() || "secondary",
+        account: secondaryAccount,
+        tokenResolution: { source: "config", token: secondaryAccount.accessToken ?? "" },
+        configured: true,
+        availableAccountIds: ["default", "secondary"],
+      }));
+      const mockSend = vi.fn().mockResolvedValue({
+        ok: true,
+        messageId: "twitch-msg-secondary",
+      });
+      vi.mocked(getClientManager).mockReturnValue({
+        sendMessage: mockSend,
+      } as unknown as ReturnType<typeof getClientManager>);
+
+      const result = await sendMessageTwitchInternal(
+        "",
+        "Hello!",
+        {
+          channels: {
+            twitch: {
+              defaultAccount: "secondary",
+            },
+          },
+        } as never,
+        undefined,
+        false,
+        mockLogger as unknown as Console,
+      );
+
+      expect(result.ok).toBe(true);
+      expect(getClientManager).toHaveBeenCalledWith("secondary");
+      expect(mockSend).toHaveBeenCalledWith(
+        secondaryAccount,
+        "secondary-channel",
+        "Hello!",
+        {
+          channels: {
+            twitch: {
+              defaultAccount: "secondary",
+            },
+          },
+        },
+        "secondary",
+      );
+    });
+  });
+});

package/src/send.ts

@@ -0,0 +1,191 @@
+/**
+ * Twitch message sending functions with dependency injection support.
+ *
+ * These functions are the primary interface for sending messages to Twitch.
+ * They support dependency injection via the `deps` parameter for testability.
+ */
+
+import {
+  createMessageReceiptFromOutboundResults,
+  type MessageReceipt,
+} from "klaw/plugin-sdk/channel-message";
+import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
+import { formatErrorMessage } from "klaw/plugin-sdk/error-runtime";
+import { getClientManager as getRegistryClientManager } from "./client-manager-registry.js";
+import { resolveTwitchAccountContext } from "./config.js";
+import { stripMarkdownForTwitch } from "./utils/markdown.js";
+import { generateMessageId, normalizeTwitchChannel } from "./utils/twitch.js";
+
+/**
+ * Result from sending a message to Twitch.
+ */
+export interface SendMessageResult {
+  /** Whether the send was successful */
+  ok: boolean;
+  /** The message ID (generated for tracking) */
+  messageId: string;
+  /** Receipt for visible sends; empty when no Twitch message was sent */
+  receipt: MessageReceipt;
+  /** Error message if the send failed */
+  error?: string;
+}
+
+function createTwitchSendReceipt(params: {
+  messageId: string;
+  channel?: string | null;
+  visible?: boolean;
+}): MessageReceipt {
+  const messageId = params.messageId.trim();
+  const conversationId = params.channel?.trim();
+  const hasVisibleMessage = params.visible === true && messageId && messageId !== "skipped";
+  return createMessageReceiptFromOutboundResults({
+    results: hasVisibleMessage
+      ? [
+          {
+            channel: "twitch",
+            messageId,
+            ...(conversationId ? { conversationId } : {}),
+          },
+        ]
+      : [],
+    kind: "text",
+  });
+}
+
+/**
+ * Internal send function used by the outbound adapter.
+ *
+ * This function has access to the full Klaw config and handles
+ * account resolution, markdown stripping, and actual message sending.
+ *
+ * @param channel - The channel name
+ * @param text - The message text
+ * @param cfg - Full Klaw configuration
+ * @param accountId - Account ID to use
+ * @param stripMarkdown - Whether to strip markdown (default: true)
+ * @param logger - Logger instance
+ * @returns Result with message ID and status
+ *
+ * @example
+ * const result = await sendMessageTwitchInternal(
+ *   "#mychannel",
+ *   "Hello Twitch!",
+ *   klawConfig,
+ *   "default",
+ *   true,
+ *   console,
+ * );
+ */
+export async function sendMessageTwitchInternal(
+  channel: string,
+  text: string,
+  cfg: KlawConfig,
+  accountId?: string,
+  stripMarkdown: boolean = true,
+  logger: Console = console,
+): Promise<SendMessageResult> {
+  const {
+    account,
+    configured,
+    availableAccountIds,
+    accountId: resolvedAccountId,
+  } = resolveTwitchAccountContext(cfg, accountId);
+  if (!account) {
+    return {
+      ok: false,
+      messageId: generateMessageId(),
+      receipt: createTwitchSendReceipt({ messageId: "", channel, visible: false }),
+      error: `Account not found: ${accountId ?? "(default)"}. Available accounts: ${availableAccountIds.join(", ") || "none"}`,
+    };
+  }
+
+  if (!configured) {
+    return {
+      ok: false,
+      messageId: generateMessageId(),
+      receipt: createTwitchSendReceipt({ messageId: "", channel, visible: false }),
+      error:
+        `Account ${resolvedAccountId} is not properly configured. ` +
+        "Required: username, clientId, and token (config or env for default account).",
+    };
+  }
+
+  const normalizedChannel = channel || account.channel;
+  if (!normalizedChannel) {
+    return {
+      ok: false,
+      messageId: generateMessageId(),
+      receipt: createTwitchSendReceipt({
+        messageId: "",
+        channel: normalizedChannel,
+        visible: false,
+      }),
+      error: "No channel specified and no default channel in account config",
+    };
+  }
+  const deliveryChannel = normalizeTwitchChannel(normalizedChannel);
+
+  const cleanedText = stripMarkdown ? stripMarkdownForTwitch(text) : text;
+  if (!cleanedText) {
+    return {
+      ok: true,
+      messageId: "skipped",
+      receipt: createTwitchSendReceipt({
+        messageId: "skipped",
+        channel: deliveryChannel,
+        visible: false,
+      }),
+    };
+  }
+
+  const clientManager = getRegistryClientManager(resolvedAccountId);
+  if (!clientManager) {
+    return {
+      ok: false,
+      messageId: generateMessageId(),
+      receipt: createTwitchSendReceipt({
+        messageId: "",
+        channel: deliveryChannel,
+        visible: false,
+      }),
+      error: `Client manager not found for account: ${resolvedAccountId}. Please start the Twitch gateway first.`,
+    };
+  }
+
+  try {
+    const result = await clientManager.sendMessage(
+      account,
+      deliveryChannel,
+      cleanedText,
+      cfg,
+      resolvedAccountId,
+    );
+
+    if (!result.ok) {
+      const messageId = result.messageId ?? generateMessageId();
+      return {
+        ok: false,
+        messageId,
+        receipt: createTwitchSendReceipt({ messageId, channel: deliveryChannel, visible: false }),
+        error: result.error ?? "Send failed",
+      };
+    }
+
+    const messageId = result.messageId ?? generateMessageId();
+    return {
+      ok: true,
+      messageId,
+      receipt: createTwitchSendReceipt({ messageId, channel: deliveryChannel, visible: true }),
+    };
+  } catch (error) {
+    const errorMsg = formatErrorMessage(error);
+    const messageId = generateMessageId();
+    logger.error(`Failed to send message: ${errorMsg}`);
+    return {
+      ok: false,
+      messageId,
+      receipt: createTwitchSendReceipt({ messageId, channel: deliveryChannel, visible: false }),
+      error: errorMsg,
+    };
+  }
+}