@openclaw/twitch 2026.5.2-beta.2 → 2026.5.3-beta.1

package/src/plugin.test.ts

@@ -1,77 +0,0 @@
-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 = {
-      channel: "secondary-channel",
-      username: "secondary",
-      accessToken: "oauth:secondary-token",
-      clientId: "secondary-client",
-      enabled: true,
-    };
-
-    const cfg = {
-      channels: {
-        twitch: {
-          accounts: {
-            default: {
-              channel: "default-channel",
-              username: "default",
-              accessToken: "oauth:default-token",
-              clientId: "default-client",
-              enabled: true,
-            },
-            secondary,
-          },
-        },
-      },
-    } as OpenClawConfig;
-
-    const snapshot = await twitchPlugin.status?.buildAccountSnapshot?.({
-      account: secondary,
-      cfg,
-    });
-
-    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");
-  });
-});

package/src/plugin.ts

@@ -1,208 +0,0 @@
-/**
- * Twitch channel plugin for OpenClaw.
- *
- * Main plugin export combining all adapters (outbound, actions, status, gateway).
- * This is the primary entry point for the Twitch channel integration.
- */
-
-import { describeAccountSnapshot } from "openclaw/plugin-sdk/account-helpers";
-import { buildChannelConfigSchema } from "openclaw/plugin-sdk/channel-config-schema";
-import { createChatChannelPlugin } from "openclaw/plugin-sdk/channel-core";
-import {
-  createLoggedPairingApprovalNotifier,
-  createPairingPrefixStripper,
-} from "openclaw/plugin-sdk/channel-pairing";
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-import { buildPassiveProbedChannelStatusSummary } from "openclaw/plugin-sdk/extension-shared";
-import {
-  createComputedAccountStatusAdapter,
-  createDefaultChannelRuntimeState,
-} from "openclaw/plugin-sdk/status-helpers";
-import { twitchMessageActions } from "./actions.js";
-import { removeClientManager } from "./client-manager-registry.js";
-import { TwitchConfigSchema } from "./config-schema.js";
-import {
-  DEFAULT_ACCOUNT_ID,
-  getAccountConfig,
-  listAccountIds,
-  resolveDefaultTwitchAccountId,
-  resolveTwitchAccountContext,
-  resolveTwitchSnapshotAccountId,
-} from "./config.js";
-import { twitchOutbound } from "./outbound.js";
-import { probeTwitch } from "./probe.js";
-import { resolveTwitchTargets } from "./resolver.js";
-import { twitchSetupAdapter, twitchSetupWizard } from "./setup-surface.js";
-import { collectTwitchStatusIssues } from "./status.js";
-import type {
-  ChannelLogSink,
-  ChannelPlugin,
-  ChannelResolveKind,
-  ChannelResolveResult,
-  TwitchAccountConfig,
-} from "./types.js";
-import { isAccountConfigured } from "./utils/twitch.js";
-
-type ResolvedTwitchAccount = TwitchAccountConfig & { accountId?: string | null };
-
-/**
- * Twitch channel plugin.
- *
- * Implements the ChannelPlugin interface to provide Twitch chat integration
- * for OpenClaw. Supports message sending, receiving, access control, and
- * status monitoring.
- */
-export const twitchPlugin: ChannelPlugin<ResolvedTwitchAccount> =
-  createChatChannelPlugin<ResolvedTwitchAccount>({
-    pairing: {
-      idLabel: "twitchUserId",
-      normalizeAllowEntry: createPairingPrefixStripper(/^(twitch:)?user:?/i),
-      notifyApproval: createLoggedPairingApprovalNotifier(
-        ({ id }) => `Pairing approved for user ${id} (notification sent via chat if possible)`,
-        console.warn,
-      ),
-    },
-    outbound: twitchOutbound,
-    base: {
-      id: "twitch",
-      meta: {
-        id: "twitch",
-        label: "Twitch",
-        selectionLabel: "Twitch (Chat)",
-        docsPath: "/channels/twitch",
-        blurb: "Twitch chat integration",
-        aliases: ["twitch-chat"],
-      },
-      setup: twitchSetupAdapter,
-      setupWizard: twitchSetupWizard,
-      capabilities: {
-        chatTypes: ["group"],
-      },
-      configSchema: buildChannelConfigSchema(TwitchConfigSchema),
-      config: {
-        listAccountIds: (cfg: OpenClawConfig): string[] => listAccountIds(cfg),
-        resolveAccount: (cfg: OpenClawConfig, accountId?: string | null): ResolvedTwitchAccount => {
-          const resolvedAccountId = accountId ?? resolveDefaultTwitchAccountId(cfg);
-          const account = getAccountConfig(cfg, resolvedAccountId);
-          if (!account) {
-            return {
-              accountId: resolvedAccountId,
-              channel: "",
-              username: "",
-              accessToken: "",
-              clientId: "",
-              enabled: false,
-            };
-          }
-          return {
-            accountId: resolvedAccountId,
-            ...account,
-          };
-        },
-        defaultAccountId: (cfg: OpenClawConfig): string => resolveDefaultTwitchAccountId(cfg),
-        isConfigured: (_account: unknown, cfg: OpenClawConfig): boolean =>
-          resolveTwitchAccountContext(cfg).configured,
-        isEnabled: (account: ResolvedTwitchAccount | undefined): boolean =>
-          account?.enabled !== false,
-        describeAccount: (account: TwitchAccountConfig | undefined) =>
-          account
-            ? describeAccountSnapshot({
-                account,
-                configured: isAccountConfigured(account, account.accessToken),
-              })
-            : {
-                accountId: DEFAULT_ACCOUNT_ID,
-                enabled: false,
-                configured: false,
-              },
-      },
-      actions: twitchMessageActions,
-      resolver: {
-        resolveTargets: async ({
-          cfg,
-          accountId,
-          inputs,
-          kind,
-          runtime,
-        }: {
-          cfg: OpenClawConfig;
-          accountId?: string | null;
-          inputs: string[];
-          kind: ChannelResolveKind;
-          runtime: import("openclaw/plugin-sdk/runtime-env").RuntimeEnv;
-        }): Promise<ChannelResolveResult[]> => {
-          const account = getAccountConfig(cfg, accountId ?? resolveDefaultTwitchAccountId(cfg));
-          if (!account) {
-            return inputs.map((input) => ({
-              input,
-              resolved: false,
-              note: "account not configured",
-            }));
-          }
-
-          const log: ChannelLogSink = {
-            info: (msg) => runtime.log(msg),
-            warn: (msg) => runtime.log(msg),
-            error: (msg) => runtime.error(msg),
-            debug: (msg) => runtime.log(msg),
-          };
-          return await resolveTwitchTargets(inputs, account, kind, log);
-        },
-      },
-      status: createComputedAccountStatusAdapter<ResolvedTwitchAccount>({
-        defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID),
-        buildChannelSummary: ({ snapshot }) => buildPassiveProbedChannelStatusSummary(snapshot),
-        probeAccount: async ({ account, timeoutMs }) => await probeTwitch(account, timeoutMs),
-        collectStatusIssues: collectTwitchStatusIssues,
-        resolveAccountSnapshot: ({ account, cfg }) => {
-          const resolvedAccountId =
-            account.accountId || resolveTwitchSnapshotAccountId(cfg, account);
-          const { configured } = resolveTwitchAccountContext(cfg, resolvedAccountId);
-          return {
-            accountId: resolvedAccountId,
-            enabled: account.enabled !== false,
-            configured,
-          };
-        },
-      }),
-      gateway: {
-        startAccount: async (ctx): Promise<void> => {
-          const account = ctx.account;
-          const accountId = ctx.accountId;
-
-          ctx.setStatus?.({
-            accountId,
-            running: true,
-            lastStartAt: Date.now(),
-            lastError: null,
-          });
-
-          ctx.log?.info(`Starting Twitch connection for ${account.username}`);
-
-          // Lazy import: the monitor pulls the reply pipeline; avoid ESM init cycles.
-          const { monitorTwitchProvider } = await import("./monitor.js");
-          await monitorTwitchProvider({
-            account,
-            accountId,
-            config: ctx.cfg,
-            runtime: ctx.runtime,
-            abortSignal: ctx.abortSignal,
-          });
-        },
-        stopAccount: async (ctx): Promise<void> => {
-          const account = ctx.account;
-          const accountId = ctx.accountId;
-
-          await removeClientManager(accountId);
-
-          ctx.setStatus?.({
-            accountId,
-            running: false,
-            lastStopAt: Date.now(),
-          });
-
-          ctx.log?.info(`Stopped Twitch connection for ${account.username}`);
-        },
-      },
-    },
-  });

package/src/probe.test.ts

@@ -1,196 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { probeTwitch } from "./probe.js";
-import type { TwitchAccountConfig } from "./types.js";
-
-// Mock Twurple modules - Vitest v4 compatible mocking
-const mockUnbind = vi.fn();
-
-// Event handler storage
-let connectHandler: (() => void) | null = null;
-let disconnectHandler: ((manually: boolean, reason?: Error) => void) | null = null;
-
-// Event listener mocks that store handlers and return unbind function
-const mockOnConnect = vi.fn((handler: () => void) => {
-  connectHandler = handler;
-  return { unbind: mockUnbind };
-});
-
-const mockOnDisconnect = vi.fn((handler: (manually: boolean, reason?: Error) => void) => {
-  disconnectHandler = handler;
-  return { unbind: mockUnbind };
-});
-
-const mockOnAuthenticationFailure = vi.fn((_handler: () => void) => {
-  return { unbind: mockUnbind };
-});
-
-// Connect mock that triggers the registered handler
-const defaultConnectImpl = async () => {
-  // Simulate successful connection by calling the handler immediately.
-  if (connectHandler) {
-    connectHandler();
-  }
-};
-
-const mockConnect = vi.fn().mockImplementation(defaultConnectImpl);
-
-const mockQuit = vi.fn().mockResolvedValue(undefined);
-
-vi.mock("@twurple/chat", () => ({
-  ChatClient: class {
-    connect = mockConnect;
-    quit = mockQuit;
-    onConnect = mockOnConnect;
-    onDisconnect = mockOnDisconnect;
-    onAuthenticationFailure = mockOnAuthenticationFailure;
-  },
-}));
-
-vi.mock("@twurple/auth", () => ({
-  StaticAuthProvider: function StaticAuthProvider() {},
-}));
-
-describe("probeTwitch", () => {
-  const mockAccount: TwitchAccountConfig = {
-    username: "testbot",
-    accessToken: "oauth:test123456789",
-    clientId: "test-client-id",
-    channel: "testchannel",
-  };
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    // Reset handlers
-    connectHandler = null;
-    disconnectHandler = null;
-  });
-
-  it("returns error when username is missing", async () => {
-    const account = { ...mockAccount, username: "" };
-    const result = await probeTwitch(account, 5000);
-
-    expect(result.ok).toBe(false);
-    expect(result.error).toContain("missing credentials");
-  });
-
-  it("returns error when token is missing", async () => {
-    const account = { ...mockAccount, accessToken: "" };
-    const result = await probeTwitch(account, 5000);
-
-    expect(result.ok).toBe(false);
-    expect(result.error).toContain("missing credentials");
-  });
-
-  it("attempts connection regardless of token prefix", async () => {
-    // Note: probeTwitch doesn't validate token format - it tries to connect with whatever token is provided
-    // The actual connection would fail in production with an invalid token
-    const account = { ...mockAccount, accessToken: "raw_token_no_prefix" };
-    const result = await probeTwitch(account, 5000);
-
-    // With mock, connection succeeds even without oauth: prefix
-    expect(result.ok).toBe(true);
-  });
-
-  it("successfully connects with valid credentials", async () => {
-    const result = await probeTwitch(mockAccount, 5000);
-
-    expect(result.ok).toBe(true);
-    expect(result.connected).toBe(true);
-    expect(result.username).toBe("testbot");
-    expect(result.channel).toBe("testchannel"); // uses account's configured channel
-  });
-
-  it("uses custom channel when specified", async () => {
-    const account: TwitchAccountConfig = {
-      ...mockAccount,
-      channel: "customchannel",
-    };
-
-    const result = await probeTwitch(account, 5000);
-
-    expect(result.ok).toBe(true);
-    expect(result.channel).toBe("customchannel");
-  });
-
-  it("times out when connection takes too long", async () => {
-    vi.useFakeTimers();
-    try {
-      mockConnect.mockImplementationOnce(() => new Promise(() => {})); // Never resolves
-      const resultPromise = probeTwitch(mockAccount, 100);
-      await vi.advanceTimersByTimeAsync(100);
-      const result = await resultPromise;
-
-      expect(result.ok).toBe(false);
-      expect(result.error).toContain("timeout");
-    } finally {
-      vi.useRealTimers();
-      mockConnect.mockImplementation(defaultConnectImpl);
-    }
-  });
-
-  it("cleans up client even on failure", async () => {
-    mockConnect.mockImplementationOnce(async () => {
-      // Simulate connection failure by calling disconnect handler
-      // onDisconnect signature: (manually: boolean, reason?: Error) => void
-      if (disconnectHandler) {
-        disconnectHandler(false, new Error("Connection failed"));
-      }
-    });
-
-    const result = await probeTwitch(mockAccount, 5000);
-
-    expect(result.ok).toBe(false);
-    expect(result.error).toContain("Connection failed");
-    expect(mockQuit).toHaveBeenCalled();
-
-    // Reset mocks
-    mockConnect.mockImplementation(defaultConnectImpl);
-  });
-
-  it("handles connection errors gracefully", async () => {
-    mockConnect.mockImplementationOnce(async () => {
-      // Simulate connection failure by calling disconnect handler
-      // onDisconnect signature: (manually: boolean, reason?: Error) => void
-      if (disconnectHandler) {
-        disconnectHandler(false, new Error("Network error"));
-      }
-    });
-
-    const result = await probeTwitch(mockAccount, 5000);
-
-    expect(result.ok).toBe(false);
-    expect(result.error).toContain("Network error");
-
-    // Reset mock
-    mockConnect.mockImplementation(defaultConnectImpl);
-  });
-
-  it("trims token before validation", async () => {
-    const account: TwitchAccountConfig = {
-      ...mockAccount,
-      accessToken: "  oauth:test123456789  ",
-    };
-
-    const result = await probeTwitch(account, 5000);
-
-    expect(result.ok).toBe(true);
-  });
-
-  it("handles non-Error objects in catch block", async () => {
-    mockConnect.mockImplementationOnce(async () => {
-      // Simulate connection failure by calling disconnect handler
-      // onDisconnect signature: (manually: boolean, reason?: Error) => void
-      if (disconnectHandler) {
-        disconnectHandler(false, "String error" as unknown as Error);
-      }
-    });
-
-    const result = await probeTwitch(mockAccount, 5000);
-
-    expect(result.ok).toBe(false);
-    expect(result.error).toBe("String error");
-
-    // Reset mock
-    mockConnect.mockImplementation(defaultConnectImpl);
-  });
-});

package/src/probe.ts

@@ -1,130 +0,0 @@
-import { StaticAuthProvider } from "@twurple/auth";
-import { ChatClient } from "@twurple/chat";
-import type { BaseProbeResult } from "openclaw/plugin-sdk/channel-contract";
-import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
-import type { TwitchAccountConfig } from "./types.js";
-import { normalizeToken } from "./utils/twitch.js";
-
-/**
- * Result of probing a Twitch account
- */
-type ProbeTwitchResult = BaseProbeResult<string> & {
-  username?: string;
-  elapsedMs: number;
-  connected?: boolean;
-  channel?: string;
-};
-
-/**
- * Probe a Twitch account to verify the connection is working
- *
- * This tests the Twitch OAuth token by attempting to connect
- * to the chat server and verify the bot's username.
- */
-export async function probeTwitch(
-  account: TwitchAccountConfig,
-  timeoutMs: number,
-): Promise<ProbeTwitchResult> {
-  const started = Date.now();
-
-  if (!account.accessToken || !account.username) {
-    return {
-      ok: false,
-      error: "missing credentials (accessToken, username)",
-      username: account.username,
-      elapsedMs: Date.now() - started,
-    };
-  }
-
-  const rawToken = normalizeToken(account.accessToken.trim());
-
-  let client: ChatClient | undefined;
-
-  try {
-    const authProvider = new StaticAuthProvider(account.clientId ?? "", rawToken);
-
-    client = new ChatClient({
-      authProvider,
-    });
-
-    // Create a promise that resolves when connected
-    const connectionPromise = new Promise<void>((resolve, reject) => {
-      let settled = false;
-      let connectListener: ReturnType<ChatClient["onConnect"]> | undefined;
-      let disconnectListener: ReturnType<ChatClient["onDisconnect"]> | undefined;
-      let authFailListener: ReturnType<ChatClient["onAuthenticationFailure"]> | undefined;
-
-      const cleanup = () => {
-        if (settled) {
-          return;
-        }
-        settled = true;
-        connectListener?.unbind();
-        disconnectListener?.unbind();
-        authFailListener?.unbind();
-      };
-
-      // Success: connection established
-      connectListener = client?.onConnect(() => {
-        cleanup();
-        resolve();
-      });
-
-      // Failure: disconnected (e.g., auth failed)
-      disconnectListener = client?.onDisconnect((_manually, reason) => {
-        cleanup();
-        reject(reason || new Error("Disconnected"));
-      });
-
-      // Failure: authentication failed
-      authFailListener = client?.onAuthenticationFailure(() => {
-        cleanup();
-        reject(new Error("Authentication failed"));
-      });
-    });
-
-    let timeoutHandle: ReturnType<typeof setTimeout> | undefined;
-    const timeout = new Promise<never>((_, reject) => {
-      timeoutHandle = setTimeout(
-        () => reject(new Error(`timeout after ${timeoutMs}ms`)),
-        timeoutMs,
-      );
-    });
-
-    client.connect();
-    try {
-      await Promise.race([connectionPromise, timeout]);
-    } finally {
-      if (timeoutHandle) {
-        clearTimeout(timeoutHandle);
-      }
-    }
-
-    client.quit();
-    client = undefined;
-
-    return {
-      ok: true,
-      connected: true,
-      username: account.username,
-      channel: account.channel,
-      elapsedMs: Date.now() - started,
-    };
-  } catch (error) {
-    return {
-      ok: false,
-      error: formatErrorMessage(error),
-      username: account.username,
-      channel: account.channel,
-      elapsedMs: Date.now() - started,
-    };
-  } finally {
-    if (client) {
-      try {
-        client.quit();
-      } catch {
-        // Ignore cleanup errors
-      }
-    }
-  }
-}