@openclaw/twitch 2026.2.21 → 2026.5.2-beta.1

package/src/status.test.ts

@@ -14,17 +14,28 @@ import { describe, expect, it } from "vitest";
 import { collectTwitchStatusIssues } from "./status.js";
 import type { ChannelAccountSnapshot } from "./types.js";
 
+function createSnapshot(overrides: Partial<ChannelAccountSnapshot> = {}): ChannelAccountSnapshot {
+  return {
+    accountId: "default",
+    configured: true,
+    enabled: true,
+    running: false,
+    ...overrides,
+  };
+}
+
+function createSimpleTwitchConfig(overrides: Record<string, unknown>) {
+  return {
+    channels: {
+      twitch: overrides,
+    },
+  };
+}
+
 describe("status", () => {
   describe("collectTwitchStatusIssues", () => {
     it("should detect unconfigured accounts", () => {
-      const snapshots: ChannelAccountSnapshot[] = [
-        {
-          accountId: "default",
-          configured: false,
-          enabled: true,
-          running: false,
-        },
-      ];
+      const snapshots: ChannelAccountSnapshot[] = [createSnapshot({ configured: false })];
 
       const issues = collectTwitchStatusIssues(snapshots);
 
@@ -34,215 +45,166 @@ describe("status", () => {
     });
 
     it("should detect disabled accounts", () => {
-      const snapshots: ChannelAccountSnapshot[] = [
-        {
-          accountId: "default",
-          configured: true,
-          enabled: false,
-          running: false,
-        },
-      ];
+      const snapshots: ChannelAccountSnapshot[] = [createSnapshot({ enabled: false })];
 
       const issues = collectTwitchStatusIssues(snapshots);
 
       expect(issues.length).toBeGreaterThan(0);
-      const disabledIssue = issues.find((i) => i.message.includes("disabled"));
-      expect(disabledIssue).toBeDefined();
+      expect(issues).toContainEqual(
+        expect.objectContaining({
+          kind: "config",
+          message: "Twitch account is disabled",
+        }),
+      );
     });
 
     it("should detect missing clientId when account configured (simplified config)", () => {
-      const snapshots: ChannelAccountSnapshot[] = [
-        {
-          accountId: "default",
-          configured: true,
-          enabled: true,
-          running: false,
-        },
-      ];
-
-      const mockCfg = {
-        channels: {
-          twitch: {
-            username: "testbot",
-            accessToken: "oauth:test123",
-            // clientId missing
-          },
-        },
-      };
+      const snapshots: ChannelAccountSnapshot[] = [createSnapshot()];
+      const mockCfg = createSimpleTwitchConfig({
+        username: "testbot",
+        accessToken: "oauth:test123",
+        // clientId missing
+      });
 
       const issues = collectTwitchStatusIssues(snapshots, () => mockCfg as never);
 
-      const clientIdIssue = issues.find((i) => i.message.includes("client ID"));
-      expect(clientIdIssue).toBeDefined();
+      expect(issues).toContainEqual(
+        expect.objectContaining({
+          kind: "config",
+          message: "Twitch client ID is required",
+        }),
+      );
     });
 
     it("should warn about oauth: prefix in token (simplified config)", () => {
-      const snapshots: ChannelAccountSnapshot[] = [
-        {
-          accountId: "default",
-          configured: true,
-          enabled: true,
-          running: false,
-        },
-      ];
-
-      const mockCfg = {
-        channels: {
-          twitch: {
-            username: "testbot",
-            accessToken: "oauth:test123", // has prefix
-            clientId: "test-id",
-          },
-        },
-      };
+      const snapshots: ChannelAccountSnapshot[] = [createSnapshot()];
+      const mockCfg = createSimpleTwitchConfig({
+        username: "testbot",
+        accessToken: "oauth:test123", // has prefix
+        clientId: "test-id",
+      });
 
       const issues = collectTwitchStatusIssues(snapshots, () => mockCfg as never);
 
-      const prefixIssue = issues.find((i) => i.message.includes("oauth:"));
-      expect(prefixIssue).toBeDefined();
-      expect(prefixIssue?.kind).toBe("config");
+      expect(issues).toContainEqual(
+        expect.objectContaining({
+          kind: "config",
+          message: "Token contains 'oauth:' prefix (will be stripped)",
+        }),
+      );
     });
 
     it("should detect clientSecret without refreshToken (simplified config)", () => {
-      const snapshots: ChannelAccountSnapshot[] = [
-        {
-          accountId: "default",
-          configured: true,
-          enabled: true,
-          running: false,
-        },
-      ];
-
-      const mockCfg = {
-        channels: {
-          twitch: {
-            username: "testbot",
-            accessToken: "oauth:test123",
-            clientId: "test-id",
-            clientSecret: "secret123",
-            // refreshToken missing
-          },
-        },
-      };
+      const snapshots: ChannelAccountSnapshot[] = [createSnapshot()];
+      const mockCfg = createSimpleTwitchConfig({
+        username: "testbot",
+        accessToken: "oauth:test123",
+        clientId: "test-id",
+        clientSecret: "secret123",
+        // refreshToken missing
+      });
 
       const issues = collectTwitchStatusIssues(snapshots, () => mockCfg as never);
 
-      const secretIssue = issues.find((i) => i.message.includes("clientSecret"));
-      expect(secretIssue).toBeDefined();
+      expect(issues).toContainEqual(
+        expect.objectContaining({
+          kind: "config",
+          message: "clientSecret provided without refreshToken",
+        }),
+      );
     });
 
     it("should detect empty allowFrom array (simplified config)", () => {
-      const snapshots: ChannelAccountSnapshot[] = [
-        {
-          accountId: "default",
-          configured: true,
-          enabled: true,
-          running: false,
-        },
-      ];
-
-      const mockCfg = {
-        channels: {
-          twitch: {
-            username: "testbot",
-            accessToken: "test123",
-            clientId: "test-id",
-            allowFrom: [], // empty array
-          },
-        },
-      };
+      const snapshots: ChannelAccountSnapshot[] = [createSnapshot()];
+      const mockCfg = createSimpleTwitchConfig({
+        username: "testbot",
+        accessToken: "test123",
+        clientId: "test-id",
+        allowFrom: [], // empty array
+      });
 
       const issues = collectTwitchStatusIssues(snapshots, () => mockCfg as never);
 
-      const allowFromIssue = issues.find((i) => i.message.includes("allowFrom"));
-      expect(allowFromIssue).toBeDefined();
+      expect(issues).toContainEqual(
+        expect.objectContaining({
+          kind: "config",
+          message: "allowFrom is configured but empty",
+        }),
+      );
     });
 
     it("should detect allowedRoles 'all' with allowFrom conflict (simplified config)", () => {
-      const snapshots: ChannelAccountSnapshot[] = [
-        {
-          accountId: "default",
-          configured: true,
-          enabled: true,
-          running: false,
-        },
-      ];
-
-      const mockCfg = {
-        channels: {
-          twitch: {
-            username: "testbot",
-            accessToken: "test123",
-            clientId: "test-id",
-            allowedRoles: ["all"],
-            allowFrom: ["123456"], // conflict!
-          },
-        },
-      };
+      const snapshots: ChannelAccountSnapshot[] = [createSnapshot()];
+      const mockCfg = createSimpleTwitchConfig({
+        username: "testbot",
+        accessToken: "test123",
+        clientId: "test-id",
+        allowedRoles: ["all"],
+        allowFrom: ["123456"], // conflict!
+      });
 
       const issues = collectTwitchStatusIssues(snapshots, () => mockCfg as never);
 
-      const conflictIssue = issues.find((i) => i.kind === "intent");
-      expect(conflictIssue).toBeDefined();
-      expect(conflictIssue?.message).toContain("allowedRoles is set to 'all'");
+      expect(issues).toContainEqual(
+        expect.objectContaining({
+          kind: "intent",
+          message: "allowedRoles is set to 'all' but allowFrom is also configured",
+        }),
+      );
     });
 
     it("should detect runtime errors", () => {
       const snapshots: ChannelAccountSnapshot[] = [
-        {
-          accountId: "default",
-          configured: true,
-          enabled: true,
-          running: false,
-          lastError: "Connection timeout",
-        },
+        createSnapshot({ lastError: "Connection timeout" }),
       ];
 
       const issues = collectTwitchStatusIssues(snapshots);
 
-      const runtimeIssue = issues.find((i) => i.kind === "runtime");
-      expect(runtimeIssue).toBeDefined();
-      expect(runtimeIssue?.message).toContain("Connection timeout");
+      expect(issues).toContainEqual(
+        expect.objectContaining({
+          kind: "runtime",
+          message: "Last error: Connection timeout",
+        }),
+      );
     });
 
     it("should detect accounts that never connected", () => {
       const snapshots: ChannelAccountSnapshot[] = [
-        {
-          accountId: "default",
-          configured: true,
-          enabled: true,
-          running: false,
+        createSnapshot({
           lastStartAt: undefined,
           lastInboundAt: undefined,
           lastOutboundAt: undefined,
-        },
+        }),
       ];
 
       const issues = collectTwitchStatusIssues(snapshots);
 
-      const neverConnectedIssue = issues.find((i) =>
-        i.message.includes("never connected successfully"),
+      expect(issues).toContainEqual(
+        expect.objectContaining({
+          kind: "runtime",
+          message: "Account has never connected successfully",
+        }),
       );
-      expect(neverConnectedIssue).toBeDefined();
     });
 
     it("should detect long-running connections", () => {
       const oldDate = Date.now() - 8 * 24 * 60 * 60 * 1000; // 8 days ago
 
       const snapshots: ChannelAccountSnapshot[] = [
-        {
-          accountId: "default",
-          configured: true,
-          enabled: true,
+        createSnapshot({
           running: true,
           lastStartAt: oldDate,
-        },
+        }),
       ];
 
       const issues = collectTwitchStatusIssues(snapshots);
 
-      const uptimeIssue = issues.find((i) => i.message.includes("running for"));
-      expect(uptimeIssue).toBeDefined();
+      expect(issues).toContainEqual(
+        expect.objectContaining({
+          kind: "runtime",
+          message: "Connection has been running for 8 days",
+        }),
+      );
     });
 
     it("should handle empty snapshots array", () => {
@@ -263,8 +225,13 @@ describe("status", () => {
 
       const issues = collectTwitchStatusIssues(snapshots);
 
-      // Should not crash, may return empty or minimal issues
-      expect(Array.isArray(issues)).toBe(true);
+      expect(issues).toEqual([
+        expect.objectContaining({
+          accountId: "unknown",
+          kind: "config",
+          message: "Twitch account is not properly configured",
+        }),
+      ]);
     });
   });
 });

package/src/status.ts

@@ -4,7 +4,7 @@
  * Detects and reports configuration issues for Twitch accounts.
  */
 
-import type { ChannelStatusIssue } from "openclaw/plugin-sdk";
+import type { ChannelStatusIssue } from "openclaw/plugin-sdk/channel-contract";
 import { getAccountConfig } from "./config.js";
 import { resolveTwitchToken } from "./token.js";
 import type { ChannelAccountSnapshot } from "./types.js";

package/src/test-fixtures.ts

@@ -1,5 +1,5 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk";
 import { afterEach, beforeEach, vi } from "vitest";
+import type { OpenClawConfig } from "../runtime-api.js";
 
 export const BASE_TWITCH_TEST_ACCOUNT = {
   username: "testbot",

package/src/token.test.ts

@@ -8,8 +8,8 @@
  * - Account ID normalization
  */
 
-import type { OpenClawConfig } from "openclaw/plugin-sdk";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { OpenClawConfig } from "../api.js";
 import { resolveTwitchToken, type TwitchTokenSource } from "./token.js";
 
 describe("token", () => {
@@ -65,6 +65,27 @@ describe("token", () => {
       expect(result.source).toBe("config");
     });
 
+    it("should resolve token from normalized account id", () => {
+      const result = resolveTwitchToken(
+        {
+          channels: {
+            twitch: {
+              accounts: {
+                Secondary: {
+                  username: "secondary",
+                  accessToken: "oauth:secondary-token",
+                },
+              },
+            },
+          },
+        } as unknown as OpenClawConfig,
+        { accountId: "secondary" },
+      );
+
+      expect(result.token).toBe("oauth:secondary-token");
+      expect(result.source).toBe("config");
+    });
+
     it("should prioritize config token over env var (simplified config)", () => {
       process.env.OPENCLAW_TWITCH_ACCESS_TOKEN = "oauth:env-token";
 

package/src/token.ts

@@ -9,8 +9,12 @@
  * 2. Environment variable: OPENCLAW_TWITCH_ACCESS_TOKEN (default account only)
  */
 
-import type { OpenClawConfig } from "../../../src/config/config.js";
-import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "../../../src/routing/session-key.js";
+import {
+  DEFAULT_ACCOUNT_ID,
+  normalizeAccountId,
+  resolveNormalizedAccountEntry,
+} from "openclaw/plugin-sdk/account-resolution";
+import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
 
 export type TwitchTokenSource = "env" | "config" | "none";
 
@@ -56,10 +60,8 @@ export function resolveTwitchToken(
 
   // Get merged account config (handles both simplified and multi-account patterns)
   const twitchCfg = cfg?.channels?.twitch;
-  const accountCfg =
-    accountId === DEFAULT_ACCOUNT_ID
-      ? (twitchCfg?.accounts?.[DEFAULT_ACCOUNT_ID] as Record<string, unknown> | undefined)
-      : (twitchCfg?.accounts?.[accountId] as Record<string, unknown> | undefined);
+  const accounts = twitchCfg?.accounts as Record<string, Record<string, unknown>> | undefined;
+  const accountCfg = resolveNormalizedAccountEntry(accounts, accountId, normalizeAccountId);
 
   // For default account, also check base-level config
   let token: string | undefined;

package/src/twitch-client.test.ts

@@ -9,7 +9,8 @@
  * - Error handling and edge cases
  */
 
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { resolveTwitchToken } from "./token.js";
 import { TwitchClientManager } from "./twitch-client.js";
 import type { ChannelLogSink, TwitchAccountConfig, TwitchChatMessage } from "./types.js";
 
@@ -21,12 +22,10 @@ const mockQuit = vi.fn();
 const mockUnbind = vi.fn();
 
 // Event handler storage for testing
-// oxlint-disable-next-line typescript/no-explicit-any
 const messageHandlers: Array<(channel: string, user: string, message: string, msg: any) => void> =
   [];
 
 // Mock functions that track handlers and return unbind objects
-// oxlint-disable-next-line typescript/no-explicit-any
 const mockOnMessage = vi.fn((handler: any) => {
   messageHandlers.push(handler);
   return { unbind: mockUnbind };
@@ -59,10 +58,8 @@ const mockAuthProvider = {
 };
 
 vi.mock("@twurple/auth", () => ({
-  StaticAuthProvider: class {
-    constructor(...args: unknown[]) {
-      mockAuthProvider.constructor(...args);
-    }
+  StaticAuthProvider: function StaticAuthProvider(...args: unknown[]) {
+    mockAuthProvider.constructor(...args);
   },
   RefreshingAuthProvider: class {
     addUserForToken = mockAddUserForToken;
@@ -83,6 +80,7 @@ vi.mock("./token.js", () => ({
 describe("TwitchClientManager", () => {
   let manager: TwitchClientManager;
   let mockLogger: ChannelLogSink;
+  let resolveTwitchTokenMock: ReturnType<typeof vi.mocked<typeof resolveTwitchToken>>;
 
   const testAccount: TwitchAccountConfig = {
     username: "testbot",
@@ -100,7 +98,11 @@ describe("TwitchClientManager", () => {
     enabled: true,
   };
 
-  beforeEach(async () => {
+  beforeAll(() => {
+    resolveTwitchTokenMock = vi.mocked(resolveTwitchToken);
+  });
+
+  beforeEach(() => {
     // Clear all mocks first
     vi.clearAllMocks();
 
@@ -108,8 +110,7 @@ describe("TwitchClientManager", () => {
     messageHandlers.length = 0;
 
     // Re-set up the default token mock implementation after clearing
-    const { resolveTwitchToken } = await import("./token.js");
-    vi.mocked(resolveTwitchToken).mockReturnValue({
+    resolveTwitchTokenMock.mockReturnValue({
       token: "oauth:mock-token-from-tests",
       source: "config" as const,
     });
@@ -176,8 +177,7 @@ describe("TwitchClientManager", () => {
       };
 
       // Override the mock to return a specific token for this test
-      const { resolveTwitchToken } = await import("./token.js");
-      vi.mocked(resolveTwitchToken).mockReturnValue({
+      resolveTwitchTokenMock.mockReturnValue({
         token: "oauth:actualtoken123",
         source: "config" as const,
       });
@@ -189,8 +189,7 @@ describe("TwitchClientManager", () => {
 
     it("should use token directly when no oauth: prefix", async () => {
       // Override the mock to return a token without oauth: prefix
-      const { resolveTwitchToken } = await import("./token.js");
-      vi.mocked(resolveTwitchToken).mockReturnValue({
+      resolveTwitchTokenMock.mockReturnValue({
         token: "oauth:mock-token-from-tests",
         source: "config" as const,
       });
@@ -221,8 +220,7 @@ describe("TwitchClientManager", () => {
 
     it("should throw error when token is missing", async () => {
       // Override the mock to return empty token
-      const { resolveTwitchToken } = await import("./token.js");
-      vi.mocked(resolveTwitchToken).mockReturnValue({
+      resolveTwitchTokenMock.mockReturnValue({
         token: "",
         source: "none" as const,
       });
@@ -271,7 +269,6 @@ describe("TwitchClientManager", () => {
 
       // Check the stored handler is handler2
       const key = manager.getAccountKey(testAccount);
-      // oxlint-disable-next-line typescript/no-explicit-any
       expect((manager as any).messageHandlers.get(key)).toBe(handler2);
     });
   });
@@ -293,9 +290,7 @@ describe("TwitchClientManager", () => {
       await manager.disconnect(testAccount);
 
       const key = manager.getAccountKey(testAccount);
-      // oxlint-disable-next-line typescript/no-explicit-any
       expect((manager as any).clients.has(key)).toBe(false);
-      // oxlint-disable-next-line typescript/no-explicit-any
       expect((manager as any).messageHandlers.has(key)).toBe(false);
     });
 
@@ -314,7 +309,6 @@ describe("TwitchClientManager", () => {
       expect(mockQuit).toHaveBeenCalledTimes(1);
 
       const key2 = manager.getAccountKey(testAccount2);
-      // oxlint-disable-next-line typescript/no-explicit-any
       expect((manager as any).clients.has(key2)).toBe(true);
     });
   });
@@ -327,9 +321,7 @@ describe("TwitchClientManager", () => {
       await manager.disconnectAll();
 
       expect(mockQuit).toHaveBeenCalledTimes(2);
-      // oxlint-disable-next-line typescript/no-explicit-any
       expect((manager as any).clients.size).toBe(0);
-      // oxlint-disable-next-line typescript/no-explicit-any
       expect((manager as any).messageHandlers.size).toBe(0);
     });
 
@@ -348,8 +340,10 @@ describe("TwitchClientManager", () => {
     it("should send message successfully", async () => {
       const result = await manager.sendMessage(testAccount, "testchannel", "Hello, world!");
 
-      expect(result.ok).toBe(true);
-      expect(result.messageId).toBeDefined();
+      expect(result).toMatchObject({ ok: true });
+      expect(result.messageId).toMatch(
+        /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
+      );
       expect(mockSay).toHaveBeenCalledWith("testchannel", "Hello, world!");
     });
 
@@ -395,7 +389,6 @@ describe("TwitchClientManager", () => {
 
     it("should create client if not already connected", async () => {
       // Clear the existing client
-      // oxlint-disable-next-line typescript/no-explicit-any
       (manager as any).clients.clear();
 
       // Reset connect call count for this specific test

package/src/twitch-client.ts

@@ -1,6 +1,7 @@
 import { RefreshingAuthProvider, StaticAuthProvider } from "@twurple/auth";
 import { ChatClient, LogLevel } from "@twurple/chat";
-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 { resolveTwitchToken } from "./token.js";
 import type { ChannelLogSink, TwitchAccountConfig, TwitchChatMessage } from "./types.js";
 import { normalizeToken } from "./utils/twitch.js";
@@ -45,7 +46,7 @@ export class TwitchClientManager {
         })
         .catch((err) => {
           this.logger.error(
-            `Failed to add user to RefreshingAuthProvider: ${err instanceof Error ? err.message : String(err)}`,
+            `Failed to add user to RefreshingAuthProvider: ${formatErrorMessage(err)}`,
           );
         });
 
@@ -250,12 +251,10 @@ export class TwitchClientManager {
 
       return { ok: true, messageId };
     } catch (error) {
-      this.logger.error(
-        `Failed to send message: ${error instanceof Error ? error.message : String(error)}`,
-      );
+      this.logger.error(`Failed to send message: ${formatErrorMessage(error)}`);
       return {
         ok: false,
-        error: error instanceof Error ? error.message : String(error),
+        error: formatErrorMessage(error),
       };
     }
   }