@openclaw/twitch 2026.5.2 → 2026.5.3-beta.2

package/src/config.ts

@@ -1,177 +0,0 @@
-import {
-  listCombinedAccountIds,
-  normalizeAccountId,
-  resolveNormalizedAccountEntry,
-} from "openclaw/plugin-sdk/account-resolution";
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-import { resolveTwitchToken, type TwitchTokenResolution } from "./token.js";
-import type { TwitchAccountConfig } from "./types.js";
-import { isAccountConfigured } from "./utils/twitch.js";
-
-/**
- * Default account ID for Twitch
- */
-export const DEFAULT_ACCOUNT_ID = "default";
-
-export type ResolvedTwitchAccountContext = {
-  accountId: string;
-  account: TwitchAccountConfig | null;
-  tokenResolution: TwitchTokenResolution;
-  configured: boolean;
-  availableAccountIds: string[];
-};
-
-/**
- * Get account config from core config
- *
- * Handles two patterns:
- * 1. Simplified single-account: base-level properties create implicit "default" account
- * 2. Multi-account: explicit accounts object
- *
- * For "default" account, base-level properties take precedence over accounts.default
- * For other accounts, only the accounts object is checked
- */
-export function getAccountConfig(
-  coreConfig: unknown,
-  accountId: string,
-): TwitchAccountConfig | null {
-  if (!coreConfig || typeof coreConfig !== "object") {
-    return null;
-  }
-
-  const cfg = coreConfig as OpenClawConfig;
-  const normalizedAccountId = normalizeAccountId(accountId);
-  const twitch = cfg.channels?.twitch;
-  // Access accounts via unknown to handle union type (single-account vs multi-account)
-  const twitchRaw = twitch as Record<string, unknown> | undefined;
-  const accounts = twitchRaw?.accounts as Record<string, TwitchAccountConfig> | undefined;
-
-  // For default account, check base-level config first
-  if (normalizedAccountId === DEFAULT_ACCOUNT_ID) {
-    const accountFromAccounts = resolveNormalizedAccountEntry(
-      accounts,
-      DEFAULT_ACCOUNT_ID,
-      normalizeAccountId,
-    );
-
-    // Base-level properties that can form an implicit default account
-    const baseLevel = {
-      username: typeof twitchRaw?.username === "string" ? twitchRaw.username : undefined,
-      accessToken: typeof twitchRaw?.accessToken === "string" ? twitchRaw.accessToken : undefined,
-      clientId: typeof twitchRaw?.clientId === "string" ? twitchRaw.clientId : undefined,
-      channel: typeof twitchRaw?.channel === "string" ? twitchRaw.channel : undefined,
-      enabled: typeof twitchRaw?.enabled === "boolean" ? twitchRaw.enabled : undefined,
-      allowFrom: Array.isArray(twitchRaw?.allowFrom) ? twitchRaw.allowFrom : undefined,
-      allowedRoles: Array.isArray(twitchRaw?.allowedRoles) ? twitchRaw.allowedRoles : undefined,
-      requireMention:
-        typeof twitchRaw?.requireMention === "boolean" ? twitchRaw.requireMention : undefined,
-      clientSecret:
-        typeof twitchRaw?.clientSecret === "string" ? twitchRaw.clientSecret : undefined,
-      refreshToken:
-        typeof twitchRaw?.refreshToken === "string" ? twitchRaw.refreshToken : undefined,
-      expiresIn: typeof twitchRaw?.expiresIn === "number" ? twitchRaw.expiresIn : undefined,
-      obtainmentTimestamp:
-        typeof twitchRaw?.obtainmentTimestamp === "number"
-          ? twitchRaw.obtainmentTimestamp
-          : undefined,
-    };
-
-    // Merge: base-level takes precedence over accounts.default
-    const merged: Partial<TwitchAccountConfig> = {
-      ...accountFromAccounts,
-      ...baseLevel,
-    } as Partial<TwitchAccountConfig>;
-
-    // Only return if we have at least username
-    if (merged.username) {
-      return merged as TwitchAccountConfig;
-    }
-
-    // Fall through to accounts.default if no base-level username
-    if (accountFromAccounts) {
-      return accountFromAccounts;
-    }
-
-    return null;
-  }
-
-  // For non-default accounts, only check accounts object
-  const account = resolveNormalizedAccountEntry(accounts, normalizedAccountId, normalizeAccountId);
-  if (!account) {
-    return null;
-  }
-
-  return account;
-}
-
-/**
- * List all configured account IDs
- *
- * Includes both explicit accounts and implicit "default" from base-level config
- */
-export function listAccountIds(cfg: OpenClawConfig): string[] {
-  const twitch = cfg.channels?.twitch;
-  // Access accounts via unknown to handle union type (single-account vs multi-account)
-  const twitchRaw = twitch as Record<string, unknown> | undefined;
-  const accountMap = twitchRaw?.accounts as Record<string, unknown> | undefined;
-
-  // Add implicit "default" if base-level config exists and "default" not already present
-  const hasBaseLevelConfig =
-    twitchRaw &&
-    (typeof twitchRaw.username === "string" ||
-      typeof twitchRaw.accessToken === "string" ||
-      typeof twitchRaw.channel === "string");
-
-  return listCombinedAccountIds({
-    configuredAccountIds: Object.keys(accountMap ?? {}).map((accountId) =>
-      normalizeAccountId(accountId),
-    ),
-    implicitAccountId: hasBaseLevelConfig ? DEFAULT_ACCOUNT_ID : undefined,
-  });
-}
-
-export function resolveDefaultTwitchAccountId(cfg: OpenClawConfig): string {
-  const preferredRaw =
-    typeof cfg.channels?.twitch?.defaultAccount === "string"
-      ? cfg.channels.twitch.defaultAccount.trim()
-      : "";
-  const preferred = preferredRaw ? normalizeAccountId(preferredRaw) : "";
-  const ids = listAccountIds(cfg);
-  if (preferred && ids.includes(preferred)) {
-    return preferred;
-  }
-  if (ids.includes(DEFAULT_ACCOUNT_ID)) {
-    return DEFAULT_ACCOUNT_ID;
-  }
-  return ids[0] ?? DEFAULT_ACCOUNT_ID;
-}
-
-export function resolveTwitchAccountContext(
-  cfg: OpenClawConfig,
-  accountId?: string | null,
-): ResolvedTwitchAccountContext {
-  const resolvedAccountId = accountId?.trim()
-    ? normalizeAccountId(accountId)
-    : resolveDefaultTwitchAccountId(cfg);
-  const account = getAccountConfig(cfg, resolvedAccountId);
-  const tokenResolution = resolveTwitchToken(cfg, { accountId: resolvedAccountId });
-  return {
-    accountId: resolvedAccountId,
-    account,
-    tokenResolution,
-    configured: account ? isAccountConfigured(account, tokenResolution.token) : false,
-    availableAccountIds: listAccountIds(cfg),
-  };
-}
-
-export function resolveTwitchSnapshotAccountId(
-  cfg: OpenClawConfig,
-  account: TwitchAccountConfig,
-): string {
-  const twitch = (cfg as Record<string, unknown>).channels as Record<string, unknown> | undefined;
-  const twitchCfg = twitch?.twitch as Record<string, unknown> | undefined;
-  const accountMap = (twitchCfg?.accounts as Record<string, unknown> | undefined) ?? {};
-  return (
-    Object.entries(accountMap).find(([, value]) => value === account)?.[0] ?? DEFAULT_ACCOUNT_ID
-  );
-}

package/src/monitor.ts

@@ -1,314 +0,0 @@
-/**
- * Twitch message monitor - processes incoming messages and routes to agents.
- *
- * This monitor connects to the Twitch client manager, processes incoming messages,
- * resolves agent routes, and handles replies.
- */
-
-import { createChannelReplyPipeline } from "openclaw/plugin-sdk/channel-reply-pipeline";
-import type { MarkdownTableMode, OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
-import type { ReplyPayload } from "openclaw/plugin-sdk/reply-runtime";
-import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/text-runtime";
-import { checkTwitchAccessControl } from "./access-control.js";
-import { getOrCreateClientManager } from "./client-manager-registry.js";
-import { getTwitchRuntime } from "./runtime.js";
-import type { TwitchAccountConfig, TwitchChatMessage } from "./types.js";
-import { stripMarkdownForTwitch } from "./utils/markdown.js";
-
-export type TwitchRuntimeEnv = {
-  log?: (message: string) => void;
-  error?: (message: string) => void;
-};
-
-export type TwitchMonitorOptions = {
-  account: TwitchAccountConfig;
-  accountId: string;
-  config: unknown; // OpenClawConfig
-  runtime: TwitchRuntimeEnv;
-  abortSignal: AbortSignal;
-  statusSink?: (patch: { lastInboundAt?: number; lastOutboundAt?: number }) => void;
-};
-
-export type TwitchMonitorResult = {
-  stop: () => void;
-};
-
-type TwitchCoreRuntime = ReturnType<typeof getTwitchRuntime>;
-
-/**
- * Process an incoming Twitch message and dispatch to agent.
- */
-async function processTwitchMessage(params: {
-  message: TwitchChatMessage;
-  account: TwitchAccountConfig;
-  accountId: string;
-  config: unknown;
-  runtime: TwitchRuntimeEnv;
-  core: TwitchCoreRuntime;
-  statusSink?: (patch: { lastInboundAt?: number; lastOutboundAt?: number }) => void;
-}): Promise<void> {
-  const { message, account, accountId, config, runtime, core, statusSink } = params;
-  const cfg = config as OpenClawConfig;
-
-  await core.channel.turn.run({
-    channel: "twitch",
-    accountId,
-    raw: message,
-    adapter: {
-      ingest: (incoming) => ({
-        id: incoming.id ?? `${incoming.channel}:${incoming.timestamp?.getTime() ?? Date.now()}`,
-        timestamp: incoming.timestamp?.getTime(),
-        rawText: incoming.message,
-        textForAgent: incoming.message,
-        textForCommands: incoming.message,
-        raw: incoming,
-      }),
-      resolveTurn: (input) => {
-        const route = core.channel.routing.resolveAgentRoute({
-          cfg,
-          channel: "twitch",
-          accountId,
-          peer: {
-            kind: "group",
-            id: message.channel,
-          },
-        });
-        const senderId = message.userId ?? message.username;
-        const fromLabel = message.displayName ?? message.username;
-        const body = core.channel.reply.formatAgentEnvelope({
-          channel: "Twitch",
-          from: fromLabel,
-          timestamp: input.timestamp,
-          envelope: core.channel.reply.resolveEnvelopeFormatOptions(cfg),
-          body: input.rawText,
-        });
-        const ctxPayload = core.channel.turn.buildContext({
-          channel: "twitch",
-          accountId,
-          messageId: input.id,
-          timestamp: input.timestamp,
-          from: `twitch:user:${senderId}`,
-          sender: {
-            id: senderId,
-            name: fromLabel,
-            username: message.username,
-          },
-          conversation: {
-            kind: "group",
-            id: message.channel,
-            label: message.channel,
-            routePeer: {
-              kind: "group",
-              id: message.channel,
-            },
-          },
-          route: {
-            agentId: route.agentId,
-            accountId: route.accountId,
-            routeSessionKey: route.sessionKey,
-          },
-          reply: {
-            to: `twitch:channel:${message.channel}`,
-            originatingTo: `twitch:channel:${message.channel}`,
-          },
-          message: {
-            body,
-            rawBody: input.rawText,
-            bodyForAgent: input.textForAgent,
-            commandBody: input.textForCommands,
-            envelopeFrom: fromLabel,
-          },
-        });
-        const storePath = core.channel.session.resolveStorePath(cfg.session?.store, {
-          agentId: route.agentId,
-        });
-        const tableMode = core.channel.text.resolveMarkdownTableMode({
-          cfg,
-          channel: "twitch",
-          accountId,
-        });
-        const { onModelSelected, ...replyPipeline } = createChannelReplyPipeline({
-          cfg,
-          agentId: route.agentId,
-          channel: "twitch",
-          accountId,
-        });
-        return {
-          cfg,
-          channel: "twitch",
-          accountId,
-          agentId: route.agentId,
-          routeSessionKey: route.sessionKey,
-          storePath,
-          ctxPayload,
-          recordInboundSession: core.channel.session.recordInboundSession,
-          dispatchReplyWithBufferedBlockDispatcher:
-            core.channel.reply.dispatchReplyWithBufferedBlockDispatcher,
-          delivery: {
-            deliver: async (payload) => {
-              await deliverTwitchReply({
-                payload,
-                channel: message.channel,
-                account,
-                accountId,
-                config,
-                tableMode,
-                runtime,
-                statusSink,
-              });
-            },
-            onError: (err, info) => {
-              runtime.error?.(`Twitch ${info.kind} reply failed: ${String(err)}`);
-            },
-          },
-          dispatcherOptions: replyPipeline,
-          replyOptions: {
-            onModelSelected,
-          },
-          record: {
-            onRecordError: (err) => {
-              runtime.error?.(`Failed updating session meta: ${String(err)}`);
-            },
-          },
-        };
-      },
-    },
-  });
-}
-
-/**
- * Deliver a reply to Twitch chat.
- */
-async function deliverTwitchReply(params: {
-  payload: ReplyPayload;
-  channel: string;
-  account: TwitchAccountConfig;
-  accountId: string;
-  config: unknown;
-  tableMode: MarkdownTableMode;
-  runtime: TwitchRuntimeEnv;
-  statusSink?: (patch: { lastInboundAt?: number; lastOutboundAt?: number }) => void;
-}): Promise<void> {
-  const { payload, channel, account, accountId, config, runtime, statusSink } = params;
-
-  try {
-    const clientManager = getOrCreateClientManager(accountId, {
-      info: (msg) => runtime.log?.(msg),
-      warn: (msg) => runtime.log?.(msg),
-      error: (msg) => runtime.error?.(msg),
-      debug: (msg) => runtime.log?.(msg),
-    });
-
-    const client = await clientManager.getClient(
-      account,
-      config as Parameters<typeof clientManager.getClient>[1],
-      accountId,
-    );
-    if (!client) {
-      runtime.error?.(`No client available for sending reply`);
-      return;
-    }
-
-    // Send the reply
-    if (!payload.text) {
-      runtime.error?.(`No text to send in reply payload`);
-      return;
-    }
-
-    const textToSend = stripMarkdownForTwitch(payload.text);
-
-    await client.say(channel, textToSend);
-    statusSink?.({ lastOutboundAt: Date.now() });
-  } catch (err) {
-    runtime.error?.(`Failed to send reply: ${String(err)}`);
-  }
-}
-
-/**
- * Main monitor provider for Twitch.
- *
- * Sets up message handlers and processes incoming messages.
- */
-export async function monitorTwitchProvider(
-  options: TwitchMonitorOptions,
-): Promise<TwitchMonitorResult> {
-  const { account, accountId, config, runtime, abortSignal, statusSink } = options;
-
-  const core = getTwitchRuntime();
-  let stopped = false;
-
-  const coreLogger = core.logging.getChildLogger({ module: "twitch" });
-  const logVerboseMessage = (message: string) => {
-    if (!core.logging.shouldLogVerbose()) {
-      return;
-    }
-    coreLogger.debug?.(message);
-  };
-  const logger = {
-    info: (msg: string) => coreLogger.info(msg),
-    warn: (msg: string) => coreLogger.warn(msg),
-    error: (msg: string) => coreLogger.error(msg),
-    debug: logVerboseMessage,
-  };
-
-  const clientManager = getOrCreateClientManager(accountId, logger);
-
-  try {
-    await clientManager.getClient(
-      account,
-      config as Parameters<typeof clientManager.getClient>[1],
-      accountId,
-    );
-  } catch (error) {
-    const errorMsg = formatErrorMessage(error);
-    runtime.error?.(`Failed to connect: ${errorMsg}`);
-    throw error;
-  }
-
-  const unregisterHandler = clientManager.onMessage(account, (message) => {
-    if (stopped) {
-      return;
-    }
-
-    // Access control check
-    const botUsername = normalizeLowercaseStringOrEmpty(account.username);
-    if (normalizeLowercaseStringOrEmpty(message.username) === botUsername) {
-      return; // Ignore own messages
-    }
-
-    const access = checkTwitchAccessControl({
-      message,
-      account,
-      botUsername,
-    });
-
-    if (!access.allowed) {
-      return;
-    }
-
-    statusSink?.({ lastInboundAt: Date.now() });
-
-    // Fire-and-forget: process message without blocking
-    void processTwitchMessage({
-      message,
-      account,
-      accountId,
-      config,
-      runtime,
-      core,
-      statusSink,
-    }).catch((err) => {
-      runtime.error?.(`Message processing failed: ${String(err)}`);
-    });
-  });
-
-  const stop = () => {
-    stopped = true;
-    unregisterHandler();
-  };
-
-  abortSignal.addEventListener("abort", stop, { once: true });
-
-  return { stop };
-}