@openclaw/twitch 2026.2.21 → 2026.5.2-beta.1

package/src/outbound.test.ts

@@ -10,6 +10,7 @@
  */
 
 import { describe, expect, it, vi } from "vitest";
+import { resolveTwitchAccountContext } from "./config.js";
 import { twitchOutbound } from "./outbound.js";
 import {
   BASE_TWITCH_TEST_ACCOUNT,
@@ -20,7 +21,7 @@ import {
 // Mock dependencies
 vi.mock("./config.js", () => ({
   DEFAULT_ACCOUNT_ID: "default",
-  getAccountConfig: vi.fn(),
+  resolveTwitchAccountContext: vi.fn(),
 }));
 
 vi.mock("./send.js", () => ({
@@ -46,6 +47,20 @@ function assertResolvedTarget(
   return result.to;
 }
 
+function expectTargetError(
+  resolveTarget: NonNullable<typeof twitchOutbound.resolveTarget>,
+  params: Parameters<NonNullable<typeof twitchOutbound.resolveTarget>>[0],
+  expectedMessage: string,
+) {
+  const result = resolveTarget(params);
+
+  expect(result.ok).toBe(false);
+  if (result.ok) {
+    throw new Error("expected resolveTarget to fail");
+  }
+  expect(result.error.message).toContain(expectedMessage);
+}
+
 describe("outbound", () => {
   const mockAccount = {
     ...BASE_TWITCH_TEST_ACCOUNT,
@@ -56,6 +71,20 @@ describe("outbound", () => {
   const mockConfig = makeTwitchTestConfig(mockAccount);
   installTwitchTestHooks();
 
+  function setupAccountContext(params?: {
+    account?: typeof mockAccount | null;
+    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 !== null,
+      availableAccountIds: params?.availableAccountIds ?? ["default"],
+    }));
+  }
+
   describe("metadata", () => {
     it("should have direct delivery mode", () => {
       expect(twitchOutbound.deliveryMode).toBe("direct");
@@ -65,9 +94,13 @@ describe("outbound", () => {
       expect(twitchOutbound.textChunkLimit).toBe(500);
     });
 
-    it("should have chunker function", () => {
-      expect(twitchOutbound.chunker).toBeDefined();
-      expect(typeof twitchOutbound.chunker).toBe("function");
+    it("should chunk long messages at 500 characters", () => {
+      const chunker = twitchOutbound.chunker;
+      if (!chunker) {
+        throw new Error("twitch outbound.chunker unavailable");
+      }
+
+      expect(chunker("a".repeat(600), 500)).toEqual(["a".repeat(500), "a".repeat(100)]);
     });
   });
 
@@ -106,17 +139,15 @@ describe("outbound", () => {
     });
 
     it("should error when target not in allowlist (implicit mode)", () => {
-      const result = resolveTarget({
-        to: "#notallowed",
-        mode: "implicit",
-        allowFrom: ["#primary", "#secondary"],
-      });
-
-      expect(result.ok).toBe(false);
-      if (result.ok) {
-        throw new Error("expected resolveTarget to fail");
-      }
-      expect(result.error.message).toContain("Twitch");
+      expectTargetError(
+        resolveTarget,
+        {
+          to: "#notallowed",
+          mode: "implicit",
+          allowFrom: ["#primary", "#secondary"],
+        },
+        "Twitch",
+      );
     });
 
     it("should accept any target when allowlist is empty", () => {
@@ -131,59 +162,51 @@ describe("outbound", () => {
     });
 
     it("should error when no target provided with allowlist", () => {
-      const result = resolveTarget({
-        to: undefined,
-        mode: "implicit",
-        allowFrom: ["#fallback", "#other"],
-      });
-
-      expect(result.ok).toBe(false);
-      if (result.ok) {
-        throw new Error("expected resolveTarget to fail");
-      }
-      expect(result.error.message).toContain("Twitch");
+      expectTargetError(
+        resolveTarget,
+        {
+          to: undefined,
+          mode: "implicit",
+          allowFrom: ["#fallback", "#other"],
+        },
+        "Twitch",
+      );
     });
 
     it("should return error when no target and no allowlist", () => {
-      const result = resolveTarget({
-        to: undefined,
-        mode: "explicit",
-        allowFrom: [],
-      });
-
-      expect(result.ok).toBe(false);
-      if (result.ok) {
-        throw new Error("expected resolveTarget to fail");
-      }
-      expect(result.error.message).toContain("Missing target");
+      expectTargetError(
+        resolveTarget,
+        {
+          to: undefined,
+          mode: "explicit",
+          allowFrom: [],
+        },
+        "Missing target",
+      );
     });
 
     it("should handle whitespace-only target", () => {
-      const result = resolveTarget({
-        to: "   ",
-        mode: "explicit",
-        allowFrom: [],
-      });
-
-      expect(result.ok).toBe(false);
-      if (result.ok) {
-        throw new Error("expected resolveTarget to fail");
-      }
-      expect(result.error.message).toContain("Missing target");
+      expectTargetError(
+        resolveTarget,
+        {
+          to: "   ",
+          mode: "explicit",
+          allowFrom: [],
+        },
+        "Missing target",
+      );
     });
 
     it("should error when target normalizes to empty string", () => {
-      const result = resolveTarget({
-        to: "#",
-        mode: "explicit",
-        allowFrom: [],
-      });
-
-      expect(result.ok).toBe(false);
-      if (result.ok) {
-        throw new Error("expected resolveTarget to fail");
-      }
-      expect(result.error.message).toContain("Twitch");
+      expectTargetError(
+        resolveTarget,
+        {
+          to: "#",
+          mode: "explicit",
+          allowFrom: [],
+        },
+        "Twitch",
+      );
     });
 
     it("should filter wildcard from allowlist when checking membership", () => {
@@ -201,10 +224,9 @@ describe("outbound", () => {
 
   describe("sendText", () => {
     it("should send message successfully", async () => {
-      const { getAccountConfig } = await import("./config.js");
       const { sendMessageTwitchInternal } = await import("./send.js");
 
-      vi.mocked(getAccountConfig).mockReturnValue(mockAccount);
+      setupAccountContext();
       vi.mocked(sendMessageTwitchInternal).mockResolvedValue({
         ok: true,
         messageId: "twitch-msg-123",
@@ -231,9 +253,7 @@ describe("outbound", () => {
     });
 
     it("should throw when account not found", async () => {
-      const { getAccountConfig } = await import("./config.js");
-
-      vi.mocked(getAccountConfig).mockReturnValue(null);
+      setupAccountContext({ account: null });
 
       await expect(
         twitchOutbound.sendText!({
@@ -246,10 +266,8 @@ describe("outbound", () => {
     });
 
     it("should throw when no channel specified", async () => {
-      const { getAccountConfig } = await import("./config.js");
-
       const accountWithoutChannel = { ...mockAccount, channel: undefined as unknown as string };
-      vi.mocked(getAccountConfig).mockReturnValue(accountWithoutChannel);
+      setupAccountContext({ account: accountWithoutChannel });
 
       await expect(
         twitchOutbound.sendText!({
@@ -262,10 +280,9 @@ describe("outbound", () => {
     });
 
     it("should use account channel when target not provided", async () => {
-      const { getAccountConfig } = await import("./config.js");
       const { sendMessageTwitchInternal } = await import("./send.js");
 
-      vi.mocked(getAccountConfig).mockReturnValue(mockAccount);
+      setupAccountContext();
       vi.mocked(sendMessageTwitchInternal).mockResolvedValue({
         ok: true,
         messageId: "msg-456",
@@ -288,6 +305,57 @@ describe("outbound", () => {
       );
     });
 
+    it("uses configured defaultAccount when accountId is omitted", async () => {
+      const { sendMessageTwitchInternal } = await import("./send.js");
+
+      vi.mocked(resolveTwitchAccountContext)
+        .mockImplementationOnce(() => ({
+          accountId: "secondary",
+          account: {
+            ...mockAccount,
+            channel: "secondary-channel",
+          },
+          tokenResolution: { source: "config", token: mockAccount.accessToken },
+          configured: true,
+          availableAccountIds: ["default", "secondary"],
+        }))
+        .mockImplementation((_cfg, accountId) => ({
+          accountId: accountId?.trim() || "secondary",
+          account: {
+            ...mockAccount,
+            channel: "secondary-channel",
+          },
+          tokenResolution: { source: "config", token: mockAccount.accessToken },
+          configured: true,
+          availableAccountIds: ["default", "secondary"],
+        }));
+      vi.mocked(sendMessageTwitchInternal).mockResolvedValue({
+        ok: true,
+        messageId: "msg-secondary",
+      });
+
+      await twitchOutbound.sendText!({
+        cfg: {
+          channels: {
+            twitch: {
+              defaultAccount: "secondary",
+            },
+          },
+        } as typeof mockConfig,
+        to: "#secondary-channel",
+        text: "Hello!",
+      });
+
+      expect(sendMessageTwitchInternal).toHaveBeenCalledWith(
+        "secondary-channel",
+        "Hello!",
+        expect.any(Object),
+        "secondary",
+        true,
+        console,
+      );
+    });
+
     it("should handle abort signal", async () => {
       const abortController = new AbortController();
       abortController.abort();
@@ -304,10 +372,9 @@ describe("outbound", () => {
     });
 
     it("should throw on send failure", async () => {
-      const { getAccountConfig } = await import("./config.js");
       const { sendMessageTwitchInternal } = await import("./send.js");
 
-      vi.mocked(getAccountConfig).mockReturnValue(mockAccount);
+      setupAccountContext();
       vi.mocked(sendMessageTwitchInternal).mockResolvedValue({
         ok: false,
         messageId: "failed-msg",
@@ -328,9 +395,8 @@ describe("outbound", () => {
   describe("sendMedia", () => {
     it("should combine text and media URL", async () => {
       const { sendMessageTwitchInternal } = await import("./send.js");
-      const { getAccountConfig } = await import("./config.js");
 
-      vi.mocked(getAccountConfig).mockReturnValue(mockAccount);
+      setupAccountContext();
       vi.mocked(sendMessageTwitchInternal).mockResolvedValue({
         ok: true,
         messageId: "media-msg-123",
@@ -358,9 +424,8 @@ describe("outbound", () => {
 
     it("should send media URL only when no text", async () => {
       const { sendMessageTwitchInternal } = await import("./send.js");
-      const { getAccountConfig } = await import("./config.js");
 
-      vi.mocked(getAccountConfig).mockReturnValue(mockAccount);
+      setupAccountContext();
       vi.mocked(sendMessageTwitchInternal).mockResolvedValue({
         ok: true,
         messageId: "media-only-msg",

package/src/outbound.ts

@@ -5,7 +5,7 @@
  * Supports text and media (URL) sending with markdown stripping and chunking.
  */
 
-import { DEFAULT_ACCOUNT_ID, getAccountConfig } from "./config.js";
+import { resolveTwitchAccountContext } from "./config.js";
 import { sendMessageTwitchInternal } from "./send.js";
 import type {
   ChannelOutboundAdapter,
@@ -113,13 +113,12 @@ export const twitchOutbound: ChannelOutboundAdapter = {
       throw new Error("Outbound delivery aborted");
     }
 
-    const resolvedAccountId = accountId ?? DEFAULT_ACCOUNT_ID;
-    const account = getAccountConfig(cfg, resolvedAccountId);
+    const resolvedAccountId = accountId ?? resolveTwitchAccountContext(cfg).accountId;
+    const { account, availableAccountIds } = resolveTwitchAccountContext(cfg, resolvedAccountId);
     if (!account) {
-      const availableIds = Object.keys(cfg.channels?.twitch?.accounts ?? {});
       throw new Error(
         `Twitch account not found: ${resolvedAccountId}. ` +
-          `Available accounts: ${availableIds.join(", ") || "none"}`,
+          `Available accounts: ${availableAccountIds.join(", ") || "none"}`,
       );
     }
 

package/src/plugin.test.ts

@@ -1,7 +1,14 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk";
 import { describe, expect, it } from "vitest";
+import type { OpenClawConfig } from "../api.js";
 import { twitchPlugin } from "./plugin.js";
 
+describe("twitchPlugin pairing", () => {
+  it("normalizes trimmed twitch user prefixes in allow entries", () => {
+    expect(twitchPlugin.pairing?.normalizeAllowEntry?.("  twitch:user:123456  ")).toBe("123456");
+    expect(twitchPlugin.pairing?.normalizeAllowEntry?.("  user789012  ")).toBe("789012");
+  });
+});
+
 describe("twitchPlugin.status.buildAccountSnapshot", () => {
   it("uses the resolved account ID for multi-account configs", async () => {
     const secondary = {
@@ -37,3 +44,34 @@ describe("twitchPlugin.status.buildAccountSnapshot", () => {
     expect(snapshot?.accountId).toBe("secondary");
   });
 });
+
+describe("twitchPlugin.config", () => {
+  it("uses configured defaultAccount for omitted-account plugin resolution", () => {
+    const cfg = {
+      channels: {
+        twitch: {
+          defaultAccount: "secondary",
+          accounts: {
+            default: {
+              channel: "default-channel",
+              username: "default",
+              accessToken: "oauth:default-token",
+              clientId: "default-client",
+              enabled: true,
+            },
+            secondary: {
+              channel: "secondary-channel",
+              username: "secondary",
+              accessToken: "oauth:secondary-token",
+              clientId: "secondary-client",
+              enabled: true,
+            },
+          },
+        },
+      },
+    } as OpenClawConfig;
+
+    expect(twitchPlugin.config.defaultAccountId?.(cfg)).toBe("secondary");
+    expect(twitchPlugin.config.resolveAccount(cfg).accountId).toBe("secondary");
+  });
+});