@openclaw/twitch 2026.2.21 → 2026.5.2-beta.1

package/src/send.test.ts

@@ -11,22 +11,24 @@
  */
 
 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",
-  getAccountConfig: vi.fn(),
+  resolveTwitchAccountContext: vi.fn(),
 }));
 
 vi.mock("./utils/twitch.js", () => ({
   generateMessageId: vi.fn(() => "test-msg-id"),
-  isAccountConfigured: vi.fn(() => true),
   normalizeTwitchChannel: (channel: string) => channel.toLowerCase().replace(/^#/, ""),
 }));
 
@@ -55,19 +57,41 @@ describe("send", () => {
   installTwitchTestHooks();
 
   describe("sendMessageTwitchInternal", () => {
-    it("should send a message successfully", async () => {
-      const { getAccountConfig } = await import("./config.js");
-      const { getClientManager } = await import("./client-manager-registry.js");
-      const { stripMarkdownForTwitch } = await import("./utils/markdown.js");
-
-      vi.mocked(getAccountConfig).mockReturnValue(mockAccount);
+    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: "twitch-msg-123",
+          messageId: params.messageId,
         }),
       } as unknown as ReturnType<typeof getClientManager>);
-      vi.mocked(stripMarkdownForTwitch).mockImplementation((text) => text);
+      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",
@@ -83,18 +107,10 @@ describe("send", () => {
     });
 
     it("should strip markdown when enabled", async () => {
-      const { getAccountConfig } = await import("./config.js");
-      const { getClientManager } = await import("./client-manager-registry.js");
-      const { stripMarkdownForTwitch } = await import("./utils/markdown.js");
-
-      vi.mocked(getAccountConfig).mockReturnValue(mockAccount);
-      vi.mocked(getClientManager).mockReturnValue({
-        sendMessage: vi.fn().mockResolvedValue({
-          ok: true,
-          messageId: "twitch-msg-456",
-        }),
-      } as unknown as ReturnType<typeof getClientManager>);
-      vi.mocked(stripMarkdownForTwitch).mockImplementation((text) => text.replace(/\*\*/g, ""));
+      const { stripMarkdownForTwitch } = await mockSuccessfulSend({
+        messageId: "twitch-msg-456",
+        stripMarkdown: (text) => text.replace(/\*\*/g, ""),
+      });
 
       await sendMessageTwitchInternal(
         "#testchannel",
@@ -109,9 +125,7 @@ describe("send", () => {
     });
 
     it("should return error when account not found", async () => {
-      const { getAccountConfig } = await import("./config.js");
-
-      vi.mocked(getAccountConfig).mockReturnValue(null);
+      setupAccountContext({ account: null });
 
       const result = await sendMessageTwitchInternal(
         "#testchannel",
@@ -127,11 +141,7 @@ describe("send", () => {
     });
 
     it("should return error when account not configured", async () => {
-      const { getAccountConfig } = await import("./config.js");
-      const { isAccountConfigured } = await import("./utils/twitch.js");
-
-      vi.mocked(getAccountConfig).mockReturnValue(mockAccount);
-      vi.mocked(isAccountConfigured).mockReturnValue(false);
+      setupAccountContext({ configured: false });
 
       const result = await sendMessageTwitchInternal(
         "#testchannel",
@@ -147,16 +157,12 @@ describe("send", () => {
     });
 
     it("should return error when no channel specified", async () => {
-      const { getAccountConfig } = await import("./config.js");
-      const { isAccountConfigured } = await import("./utils/twitch.js");
-
       // Set channel to undefined to trigger the error (bypassing type check)
       const accountWithoutChannel = {
         ...mockAccount,
         channel: undefined as unknown as string,
       };
-      vi.mocked(getAccountConfig).mockReturnValue(accountWithoutChannel);
-      vi.mocked(isAccountConfigured).mockReturnValue(true);
+      setupAccountContext({ account: accountWithoutChannel });
 
       const result = await sendMessageTwitchInternal(
         "",
@@ -172,12 +178,7 @@ describe("send", () => {
     });
 
     it("should skip sending empty message after markdown stripping", async () => {
-      const { getAccountConfig } = await import("./config.js");
-      const { isAccountConfigured } = await import("./utils/twitch.js");
-      const { stripMarkdownForTwitch } = await import("./utils/markdown.js");
-
-      vi.mocked(getAccountConfig).mockReturnValue(mockAccount);
-      vi.mocked(isAccountConfigured).mockReturnValue(true);
+      setupAccountContext();
       vi.mocked(stripMarkdownForTwitch).mockReturnValue("");
 
       const result = await sendMessageTwitchInternal(
@@ -194,12 +195,7 @@ describe("send", () => {
     });
 
     it("should return error when client manager not found", async () => {
-      const { getAccountConfig } = await import("./config.js");
-      const { isAccountConfigured } = await import("./utils/twitch.js");
-      const { getClientManager } = await import("./client-manager-registry.js");
-
-      vi.mocked(getAccountConfig).mockReturnValue(mockAccount);
-      vi.mocked(isAccountConfigured).mockReturnValue(true);
+      setupAccountContext();
       vi.mocked(getClientManager).mockReturnValue(undefined);
 
       const result = await sendMessageTwitchInternal(
@@ -216,12 +212,7 @@ describe("send", () => {
     });
 
     it("should handle send errors gracefully", async () => {
-      const { getAccountConfig } = await import("./config.js");
-      const { isAccountConfigured } = await import("./utils/twitch.js");
-      const { getClientManager } = await import("./client-manager-registry.js");
-
-      vi.mocked(getAccountConfig).mockReturnValue(mockAccount);
-      vi.mocked(isAccountConfigured).mockReturnValue(true);
+      setupAccountContext();
       vi.mocked(getClientManager).mockReturnValue({
         sendMessage: vi.fn().mockRejectedValue(new Error("Connection lost")),
       } as unknown as ReturnType<typeof getClientManager>);
@@ -241,12 +232,7 @@ describe("send", () => {
     });
 
     it("should use account channel when channel parameter is empty", async () => {
-      const { getAccountConfig } = await import("./config.js");
-      const { isAccountConfigured } = await import("./utils/twitch.js");
-      const { getClientManager } = await import("./client-manager-registry.js");
-
-      vi.mocked(getAccountConfig).mockReturnValue(mockAccount);
-      vi.mocked(isAccountConfigured).mockReturnValue(true);
+      setupAccountContext();
       const mockSend = vi.fn().mockResolvedValue({
         ok: true,
         messageId: "twitch-msg-789",
@@ -272,5 +258,52 @@ describe("send", () => {
         "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!",
+        expect.any(Object),
+        "secondary",
+      );
+    });
   });
 });

package/src/send.ts

@@ -5,12 +5,12 @@
  * They support dependency injection via the `deps` parameter for testability.
  */
 
-import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
+import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { getClientManager as getRegistryClientManager } from "./client-manager-registry.js";
-import { DEFAULT_ACCOUNT_ID, getAccountConfig } from "./config.js";
-import { resolveTwitchToken } from "./token.js";
+import { resolveTwitchAccountContext } from "./config.js";
 import { stripMarkdownForTwitch } from "./utils/markdown.js";
-import { generateMessageId, isAccountConfigured, normalizeTwitchChannel } from "./utils/twitch.js";
+import { generateMessageId, normalizeTwitchChannel } from "./utils/twitch.js";
 
 /**
  * Result from sending a message to Twitch.
@@ -52,27 +52,30 @@ export async function sendMessageTwitchInternal(
   channel: string,
   text: string,
   cfg: OpenClawConfig,
-  accountId: string = DEFAULT_ACCOUNT_ID,
+  accountId?: string,
   stripMarkdown: boolean = true,
   logger: Console = console,
 ): Promise<SendMessageResult> {
-  const account = getAccountConfig(cfg, accountId);
+  const {
+    account,
+    configured,
+    availableAccountIds,
+    accountId: resolvedAccountId,
+  } = resolveTwitchAccountContext(cfg, accountId);
   if (!account) {
-    const availableIds = Object.keys(cfg.channels?.twitch?.accounts ?? {});
     return {
       ok: false,
       messageId: generateMessageId(),
-      error: `Account not found: ${accountId}. Available accounts: ${availableIds.join(", ") || "none"}`,
+      error: `Account not found: ${accountId ?? "(default)"}. Available accounts: ${availableAccountIds.join(", ") || "none"}`,
     };
   }
 
-  const tokenResolution = resolveTwitchToken(cfg, { accountId });
-  if (!isAccountConfigured(account, tokenResolution.token)) {
+  if (!configured) {
     return {
       ok: false,
       messageId: generateMessageId(),
       error:
-        `Account ${accountId} is not properly configured. ` +
+        `Account ${resolvedAccountId} is not properly configured. ` +
         "Required: username, clientId, and token (config or env for default account).",
     };
   }
@@ -94,12 +97,12 @@ export async function sendMessageTwitchInternal(
     };
   }
 
-  const clientManager = getRegistryClientManager(accountId);
+  const clientManager = getRegistryClientManager(resolvedAccountId);
   if (!clientManager) {
     return {
       ok: false,
       messageId: generateMessageId(),
-      error: `Client manager not found for account: ${accountId}. Please start the Twitch gateway first.`,
+      error: `Client manager not found for account: ${resolvedAccountId}. Please start the Twitch gateway first.`,
     };
   }
 
@@ -109,7 +112,7 @@ export async function sendMessageTwitchInternal(
       normalizeTwitchChannel(normalizedChannel),
       cleanedText,
       cfg,
-      accountId,
+      resolvedAccountId,
     );
 
     if (!result.ok) {
@@ -125,7 +128,7 @@ export async function sendMessageTwitchInternal(
       messageId: result.messageId ?? generateMessageId(),
     };
   } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : String(error);
+    const errorMsg = formatErrorMessage(error);
     logger.error(`Failed to send message: ${errorMsg}`);
     return {
       ok: false,