@kodelyth/twitch 2026.5.42 → 2026.6.2

package/src/send.test.ts

@@ -1,342 +0,0 @@
-/**
- * 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

@@ -1,191 +0,0 @@
-/**
- * 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,
-    };
-  }
-}