stableclaw 2026.4.6 → 2026.4.8

package/dist/extensions/twitch/index.js

@@ -1,1090 +0,0 @@
-import { t as formatDocsLink } from "../../links-D7o22Ygt.js";
-import { h as MarkdownConfigSchema } from "../../zod-schema.core-C1Ewlj9j.js";
-import { r as buildChannelConfigSchema } from "../../config-schema-mfJ91WLf.js";
-import { d as createDefaultChannelRuntimeState, u as createComputedAccountStatusAdapter } from "../../status-helpers-CCJSSrVJ.js";
-import { i as listCombinedAccountIds, n as describeAccountSnapshot } from "../../account-helpers-jJOgsae3.js";
-import { i as defineChannelPluginEntry, r as createChatChannelPlugin } from "../../core-DaMVvavf.js";
-import "../../setup-BrOJEPVN.js";
-import "../../account-resolution-CbKUJkzG.js";
-import { i as createPairingPrefixStripper, r as createLoggedPairingApprovalNotifier } from "../../channel-pairing-Byr3MFbN.js";
-import { n as buildPassiveProbedChannelStatusSummary } from "../../extension-shared-V_4IXpRU.js";
-import "../../channel-config-primitives-DwsP66Ak.js";
-import { t as zod_exports } from "../../zod-1Wegy5nx.js";
-import "../../api-w-46PN0B.js";
-import { a as getClientManager, c as isAccountConfigured, d as normalizeTwitchChannel, f as resolveTwitchToken, i as stripMarkdownForTwitch, l as missingTargetError, n as setTwitchRuntime, o as removeClientManager, r as chunkTextForTwitch, s as generateMessageId, t as monitorTwitchProvider, u as normalizeToken } from "../../monitor-BiwufaF7.js";
-import { StaticAuthProvider } from "@twurple/auth";
-import { ChatClient } from "@twurple/chat";
-import { ApiClient } from "@twurple/api";
-//#region extensions/twitch/src/config.ts
-/**
-* Default account ID for Twitch
-*/
-const DEFAULT_ACCOUNT_ID = "default";
-/**
-* 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
-*/
-function getAccountConfig(coreConfig, accountId) {
-	if (!coreConfig || typeof coreConfig !== "object") return null;
-	const twitchRaw = coreConfig.channels?.twitch;
-	const accounts = twitchRaw?.accounts;
-	if (accountId === "default") {
-		const accountFromAccounts = accounts?.[DEFAULT_ACCOUNT_ID];
-		const baseLevel = {
-			username: typeof twitchRaw?.username === "string" ? twitchRaw.username : void 0,
-			accessToken: typeof twitchRaw?.accessToken === "string" ? twitchRaw.accessToken : void 0,
-			clientId: typeof twitchRaw?.clientId === "string" ? twitchRaw.clientId : void 0,
-			channel: typeof twitchRaw?.channel === "string" ? twitchRaw.channel : void 0,
-			enabled: typeof twitchRaw?.enabled === "boolean" ? twitchRaw.enabled : void 0,
-			allowFrom: Array.isArray(twitchRaw?.allowFrom) ? twitchRaw.allowFrom : void 0,
-			allowedRoles: Array.isArray(twitchRaw?.allowedRoles) ? twitchRaw.allowedRoles : void 0,
-			requireMention: typeof twitchRaw?.requireMention === "boolean" ? twitchRaw.requireMention : void 0,
-			clientSecret: typeof twitchRaw?.clientSecret === "string" ? twitchRaw.clientSecret : void 0,
-			refreshToken: typeof twitchRaw?.refreshToken === "string" ? twitchRaw.refreshToken : void 0,
-			expiresIn: typeof twitchRaw?.expiresIn === "number" ? twitchRaw.expiresIn : void 0,
-			obtainmentTimestamp: typeof twitchRaw?.obtainmentTimestamp === "number" ? twitchRaw.obtainmentTimestamp : void 0
-		};
-		const merged = {
-			...accountFromAccounts,
-			...baseLevel
-		};
-		if (merged.username) return merged;
-		if (accountFromAccounts) return accountFromAccounts;
-		return null;
-	}
-	if (!accounts || !accounts[accountId]) return null;
-	return accounts[accountId];
-}
-/**
-* List all configured account IDs
-*
-* Includes both explicit accounts and implicit "default" from base-level config
-*/
-function listAccountIds(cfg) {
-	const twitchRaw = cfg.channels?.twitch;
-	const accountMap = twitchRaw?.accounts;
-	const hasBaseLevelConfig = twitchRaw && (typeof twitchRaw.username === "string" || typeof twitchRaw.accessToken === "string" || typeof twitchRaw.channel === "string");
-	return listCombinedAccountIds({
-		configuredAccountIds: Object.keys(accountMap ?? {}),
-		implicitAccountId: hasBaseLevelConfig ? DEFAULT_ACCOUNT_ID : void 0
-	});
-}
-function resolveTwitchAccountContext(cfg, accountId) {
-	const resolvedAccountId = accountId?.trim() || "default";
-	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)
-	};
-}
-function resolveTwitchSnapshotAccountId(cfg, account) {
-	const accountMap = (cfg.channels?.twitch)?.accounts ?? {};
-	return Object.entries(accountMap).find(([, value]) => value === account)?.[0] ?? "default";
-}
-//#endregion
-//#region extensions/twitch/src/send.ts
-/**
-* Internal send function used by the outbound adapter.
-*
-* This function has access to the full OpenClaw config and handles
-* account resolution, markdown stripping, and actual message sending.
-*
-* @param channel - The channel name
-* @param text - The message text
-* @param cfg - Full OpenClaw configuration
-* @param accountId - Account ID to use
-* @param stripMarkdown - Whether to strip markdown (default: true)
-* @param logger - Logger instance
-* @returns Result with message ID and status
-*
-* @example
-* const result = await sendMessageTwitchInternal(
-*   "#mychannel",
-*   "Hello Twitch!",
-*   openclawConfig,
-*   "default",
-*   true,
-*   console,
-* );
-*/
-async function sendMessageTwitchInternal(channel, text, cfg, accountId = DEFAULT_ACCOUNT_ID, stripMarkdown = true, logger = console) {
-	const { account, configured, availableAccountIds } = resolveTwitchAccountContext(cfg, accountId);
-	if (!account) return {
-		ok: false,
-		messageId: generateMessageId(),
-		error: `Account not found: ${accountId}. Available accounts: ${availableAccountIds.join(", ") || "none"}`
-	};
-	if (!configured) return {
-		ok: false,
-		messageId: generateMessageId(),
-		error: `Account ${accountId} is not properly configured. Required: username, clientId, and token (config or env for default account).`
-	};
-	const normalizedChannel = channel || account.channel;
-	if (!normalizedChannel) return {
-		ok: false,
-		messageId: generateMessageId(),
-		error: "No channel specified and no default channel in account config"
-	};
-	const cleanedText = stripMarkdown ? stripMarkdownForTwitch(text) : text;
-	if (!cleanedText) return {
-		ok: true,
-		messageId: "skipped"
-	};
-	const clientManager = getClientManager(accountId);
-	if (!clientManager) return {
-		ok: false,
-		messageId: generateMessageId(),
-		error: `Client manager not found for account: ${accountId}. Please start the Twitch gateway first.`
-	};
-	try {
-		const result = await clientManager.sendMessage(account, normalizeTwitchChannel(normalizedChannel), cleanedText, cfg, accountId);
-		if (!result.ok) return {
-			ok: false,
-			messageId: result.messageId ?? generateMessageId(),
-			error: result.error ?? "Send failed"
-		};
-		return {
-			ok: true,
-			messageId: result.messageId ?? generateMessageId()
-		};
-	} catch (error) {
-		const errorMsg = error instanceof Error ? error.message : String(error);
-		logger.error(`Failed to send message: ${errorMsg}`);
-		return {
-			ok: false,
-			messageId: generateMessageId(),
-			error: errorMsg
-		};
-	}
-}
-//#endregion
-//#region extensions/twitch/src/outbound.ts
-/**
-* Twitch outbound adapter for sending messages.
-*
-* Implements the ChannelOutboundAdapter interface for Twitch chat.
-* Supports text and media (URL) sending with markdown stripping and chunking.
-*/
-/**
-* Twitch outbound adapter.
-*
-* Handles sending text and media to Twitch channels with automatic
-* markdown stripping and message chunking.
-*/
-const twitchOutbound = {
-	deliveryMode: "direct",
-	textChunkLimit: 500,
-	chunker: chunkTextForTwitch,
-	resolveTarget: ({ to, allowFrom, mode }) => {
-		const trimmed = to?.trim() ?? "";
-		const allowListRaw = (allowFrom ?? []).map((entry) => String(entry).trim()).filter(Boolean);
-		const hasWildcard = allowListRaw.includes("*");
-		const allowList = allowListRaw.filter((entry) => entry !== "*").map((entry) => normalizeTwitchChannel(entry)).filter((entry) => entry.length > 0);
-		if (trimmed) {
-			const normalizedTo = normalizeTwitchChannel(trimmed);
-			if (!normalizedTo) return {
-				ok: false,
-				error: missingTargetError("Twitch", "<channel-name>")
-			};
-			if (mode === "implicit" || mode === "heartbeat") {
-				if (hasWildcard || allowList.length === 0) return {
-					ok: true,
-					to: normalizedTo
-				};
-				if (allowList.includes(normalizedTo)) return {
-					ok: true,
-					to: normalizedTo
-				};
-				return {
-					ok: false,
-					error: missingTargetError("Twitch", "<channel-name>")
-				};
-			}
-			return {
-				ok: true,
-				to: normalizedTo
-			};
-		}
-		return {
-			ok: false,
-			error: missingTargetError("Twitch", "<channel-name>")
-		};
-	},
-	sendText: async (params) => {
-		const { cfg, to, text, accountId } = params;
-		if (params.signal?.aborted) throw new Error("Outbound delivery aborted");
-		const resolvedAccountId = accountId ?? "default";
-		const { account, availableAccountIds } = resolveTwitchAccountContext(cfg, resolvedAccountId);
-		if (!account) throw new Error(`Twitch account not found: ${resolvedAccountId}. Available accounts: ${availableAccountIds.join(", ") || "none"}`);
-		const channel = to || account.channel;
-		if (!channel) throw new Error("No channel specified and no default channel in account config");
-		const result = await sendMessageTwitchInternal(normalizeTwitchChannel(channel), text, cfg, resolvedAccountId, true, console);
-		if (!result.ok) throw new Error(result.error ?? "Send failed");
-		return {
-			channel: "twitch",
-			messageId: result.messageId,
-			timestamp: Date.now()
-		};
-	},
-	sendMedia: async (params) => {
-		const { text, mediaUrl } = params;
-		if (params.signal?.aborted) throw new Error("Outbound delivery aborted");
-		const message = mediaUrl ? `${text || ""} ${mediaUrl}`.trim() : text;
-		if (!twitchOutbound.sendText) throw new Error("sendText not implemented");
-		return twitchOutbound.sendText({
-			...params,
-			text: message
-		});
-	}
-};
-//#endregion
-//#region extensions/twitch/src/actions.ts
-/**
-* Twitch message actions adapter.
-*
-* Handles tool-based actions for Twitch, such as sending messages.
-*/
-/**
-* Create a tool result with error content.
-*/
-function errorResponse(error) {
-	return {
-		content: [{
-			type: "text",
-			text: JSON.stringify({
-				ok: false,
-				error
-			})
-		}],
-		details: { ok: false }
-	};
-}
-/**
-* Read a string parameter from action arguments.
-*
-* @param args - Action arguments
-* @param key - Parameter key
-* @param options - Options for reading the parameter
-* @returns The parameter value or undefined if not found
-*/
-function readStringParam(args, key, options = {}) {
-	const value = args[key];
-	if (value === void 0 || value === null) {
-		if (options.required) throw new Error(`Missing required parameter: ${key}`);
-		return;
-	}
-	if (typeof value === "string") return options.trim !== false ? value.trim() : value;
-	if (typeof value === "number" || typeof value === "boolean") {
-		const str = String(value);
-		return options.trim !== false ? str.trim() : str;
-	}
-	throw new Error(`Parameter ${key} must be a string, number, or boolean`);
-}
-/** Supported Twitch actions */
-const TWITCH_ACTIONS = new Set(["send"]);
-/**
-* Twitch message actions adapter.
-*/
-const twitchMessageActions = {
-	describeMessageTool: () => ({ actions: [...TWITCH_ACTIONS] }),
-	supportsAction: ({ action }) => TWITCH_ACTIONS.has(action),
-	extractToolSend: ({ args }) => {
-		try {
-			const to = readStringParam(args, "to", { required: true });
-			const message = readStringParam(args, "message", { required: true });
-			if (!to || !message) return null;
-			return {
-				to,
-				message
-			};
-		} catch {
-			return null;
-		}
-	},
-	handleAction: async (ctx) => {
-		if (ctx.action !== "send") return {
-			content: [{
-				type: "text",
-				text: "Unsupported action"
-			}],
-			details: {
-				ok: false,
-				error: "Unsupported action"
-			}
-		};
-		const message = readStringParam(ctx.params, "message", { required: true });
-		const to = readStringParam(ctx.params, "to", { required: false });
-		const accountId = ctx.accountId ?? "default";
-		const { account, availableAccountIds } = resolveTwitchAccountContext(ctx.cfg, accountId);
-		if (!account) return errorResponse(`Account not found: ${accountId}. Available accounts: ${availableAccountIds.join(", ") || "none"}`);
-		const targetChannel = to || account.channel;
-		if (!targetChannel) return errorResponse("No channel specified and no default channel in account config");
-		if (!twitchOutbound.sendText) return errorResponse("sendText not implemented");
-		try {
-			const result = await twitchOutbound.sendText({
-				cfg: ctx.cfg,
-				to: targetChannel,
-				text: message ?? "",
-				accountId
-			});
-			return {
-				content: [{
-					type: "text",
-					text: JSON.stringify(result)
-				}],
-				details: { ok: true }
-			};
-		} catch (error) {
-			return errorResponse(error instanceof Error ? error.message : String(error));
-		}
-	}
-};
-//#endregion
-//#region extensions/twitch/src/config-schema.ts
-/**
-* Twitch user roles that can be allowed to interact with the bot
-*/
-const TwitchRoleSchema = zod_exports.z.enum([
-	"moderator",
-	"owner",
-	"vip",
-	"subscriber",
-	"all"
-]);
-/**
-* Twitch account configuration schema
-*/
-const TwitchAccountSchema = zod_exports.z.object({
-	username: zod_exports.z.string(),
-	accessToken: zod_exports.z.string(),
-	clientId: zod_exports.z.string().optional(),
-	channel: zod_exports.z.string().min(1),
-	enabled: zod_exports.z.boolean().optional(),
-	allowFrom: zod_exports.z.array(zod_exports.z.string()).optional(),
-	allowedRoles: zod_exports.z.array(TwitchRoleSchema).optional(),
-	requireMention: zod_exports.z.boolean().optional(),
-	responsePrefix: zod_exports.z.string().optional(),
-	clientSecret: zod_exports.z.string().optional(),
-	refreshToken: zod_exports.z.string().optional(),
-	expiresIn: zod_exports.z.number().nullable().optional(),
-	obtainmentTimestamp: zod_exports.z.number().optional()
-});
-/**
-* Base configuration properties shared by both single and multi-account modes
-*/
-const TwitchConfigBaseSchema = zod_exports.z.object({
-	name: zod_exports.z.string().optional(),
-	enabled: zod_exports.z.boolean().optional(),
-	markdown: MarkdownConfigSchema.optional()
-});
-/**
-* Simplified single-account configuration schema
-*
-* Use this for single-account setups. Properties are at the top level,
-* creating an implicit "default" account.
-*/
-const SimplifiedSchema = zod_exports.z.intersection(TwitchConfigBaseSchema, TwitchAccountSchema);
-/**
-* Multi-account configuration schema
-*
-* Use this for multi-account setups. Each key is an account ID (e.g., "default", "secondary").
-*/
-const MultiAccountSchema = zod_exports.z.intersection(TwitchConfigBaseSchema, zod_exports.z.object({ accounts: zod_exports.z.record(zod_exports.z.string(), TwitchAccountSchema) }).refine((val) => Object.keys(val.accounts || {}).length > 0, { message: "accounts must contain at least one entry" }));
-/**
-* Twitch plugin configuration schema
-*
-* Supports two mutually exclusive patterns:
-* 1. Simplified single-account: username, accessToken, clientId, channel at top level
-* 2. Multi-account: accounts object with named account configs
-*
-* The union ensures clear discrimination between the two modes.
-*/
-const TwitchConfigSchema = zod_exports.z.union([SimplifiedSchema, MultiAccountSchema]);
-//#endregion
-//#region extensions/twitch/src/probe.ts
-/**
-* 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.
-*/
-async function probeTwitch(account, timeoutMs) {
-	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;
-	try {
-		client = new ChatClient({ authProvider: new StaticAuthProvider(account.clientId ?? "", rawToken) });
-		const connectionPromise = new Promise((resolve, reject) => {
-			let settled = false;
-			let connectListener;
-			let disconnectListener;
-			let authFailListener;
-			const cleanup = () => {
-				if (settled) return;
-				settled = true;
-				connectListener?.unbind();
-				disconnectListener?.unbind();
-				authFailListener?.unbind();
-			};
-			connectListener = client?.onConnect(() => {
-				cleanup();
-				resolve();
-			});
-			disconnectListener = client?.onDisconnect((_manually, reason) => {
-				cleanup();
-				reject(reason || /* @__PURE__ */ new Error("Disconnected"));
-			});
-			authFailListener = client?.onAuthenticationFailure(() => {
-				cleanup();
-				reject(/* @__PURE__ */ new Error("Authentication failed"));
-			});
-		});
-		const timeout = new Promise((_, reject) => {
-			setTimeout(() => reject(/* @__PURE__ */ new Error(`timeout after ${timeoutMs}ms`)), timeoutMs);
-		});
-		client.connect();
-		await Promise.race([connectionPromise, timeout]);
-		client.quit();
-		client = void 0;
-		return {
-			ok: true,
-			connected: true,
-			username: account.username,
-			channel: account.channel,
-			elapsedMs: Date.now() - started
-		};
-	} catch (error) {
-		return {
-			ok: false,
-			error: error instanceof Error ? error.message : String(error),
-			username: account.username,
-			channel: account.channel,
-			elapsedMs: Date.now() - started
-		};
-	} finally {
-		if (client) try {
-			client.quit();
-		} catch {}
-	}
-}
-//#endregion
-//#region extensions/twitch/src/resolver.ts
-/**
-* Twitch resolver adapter for channel/user name resolution.
-*
-* This module implements the ChannelResolverAdapter interface to resolve
-* Twitch usernames to user IDs via the Twitch Helix API.
-*/
-/**
-* Normalize a Twitch username - strip @ prefix and convert to lowercase
-*/
-function normalizeUsername(input) {
-	const trimmed = input.trim();
-	if (trimmed.startsWith("@")) return trimmed.slice(1).toLowerCase();
-	return trimmed.toLowerCase();
-}
-/**
-* Create a logger that includes the Twitch prefix
-*/
-function createLogger(logger) {
-	return {
-		info: (msg) => logger?.info(msg),
-		warn: (msg) => logger?.warn(msg),
-		error: (msg) => logger?.error(msg),
-		debug: (msg) => logger?.debug?.(msg) ?? (() => {})
-	};
-}
-/**
-* Resolve Twitch usernames to user IDs via the Helix API
-*
-* @param inputs - Array of usernames or user IDs to resolve
-* @param account - Twitch account configuration with auth credentials
-* @param kind - Type of target to resolve ("user" or "group")
-* @param logger - Optional logger
-* @returns Promise resolving to array of ChannelResolveResult
-*/
-async function resolveTwitchTargets(inputs, account, kind, logger) {
-	const log = createLogger(logger);
-	if (!account.clientId || !account.accessToken) {
-		log.error("Missing Twitch client ID or accessToken");
-		return inputs.map((input) => ({
-			input,
-			resolved: false,
-			note: "missing Twitch credentials"
-		}));
-	}
-	const normalizedToken = normalizeToken(account.accessToken);
-	const apiClient = new ApiClient({ authProvider: new StaticAuthProvider(account.clientId, normalizedToken) });
-	const results = [];
-	for (const input of inputs) {
-		const normalized = normalizeUsername(input);
-		if (!normalized) {
-			results.push({
-				input,
-				resolved: false,
-				note: "empty input"
-			});
-			continue;
-		}
-		const looksLikeUserId = /^\d+$/.test(normalized);
-		try {
-			if (looksLikeUserId) {
-				const user = await apiClient.users.getUserById(normalized);
-				if (user) {
-					results.push({
-						input,
-						resolved: true,
-						id: user.id,
-						name: user.name
-					});
-					log.debug?.(`Resolved user ID ${normalized} -> ${user.name}`);
-				} else {
-					results.push({
-						input,
-						resolved: false,
-						note: "user ID not found"
-					});
-					log.warn(`User ID ${normalized} not found`);
-				}
-			} else {
-				const user = await apiClient.users.getUserByName(normalized);
-				if (user) {
-					results.push({
-						input,
-						resolved: true,
-						id: user.id,
-						name: user.name,
-						note: user.displayName !== user.name ? `display: ${user.displayName}` : void 0
-					});
-					log.debug?.(`Resolved username ${normalized} -> ${user.id} (${user.name})`);
-				} else {
-					results.push({
-						input,
-						resolved: false,
-						note: "username not found"
-					});
-					log.warn(`Username ${normalized} not found`);
-				}
-			}
-		} catch (error) {
-			const errorMessage = error instanceof Error ? error.message : String(error);
-			results.push({
-				input,
-				resolved: false,
-				note: `API error: ${errorMessage}`
-			});
-			log.error(`Failed to resolve ${input}: ${errorMessage}`);
-		}
-	}
-	return results;
-}
-//#endregion
-//#region extensions/twitch/src/setup-surface.ts
-/**
-* Twitch setup wizard surface for CLI setup.
-*/
-const channel = "twitch";
-function setTwitchAccount(cfg, account) {
-	const existing = getAccountConfig(cfg, DEFAULT_ACCOUNT_ID);
-	const merged = {
-		username: account.username ?? existing?.username ?? "",
-		accessToken: account.accessToken ?? existing?.accessToken ?? "",
-		clientId: account.clientId ?? existing?.clientId ?? "",
-		channel: account.channel ?? existing?.channel ?? "",
-		enabled: account.enabled ?? existing?.enabled ?? true,
-		allowFrom: account.allowFrom ?? existing?.allowFrom,
-		allowedRoles: account.allowedRoles ?? existing?.allowedRoles,
-		requireMention: account.requireMention ?? existing?.requireMention,
-		clientSecret: account.clientSecret ?? existing?.clientSecret,
-		refreshToken: account.refreshToken ?? existing?.refreshToken,
-		expiresIn: account.expiresIn ?? existing?.expiresIn,
-		obtainmentTimestamp: account.obtainmentTimestamp ?? existing?.obtainmentTimestamp
-	};
-	return {
-		...cfg,
-		channels: {
-			...cfg.channels,
-			twitch: {
-				...cfg.channels?.twitch,
-				enabled: true,
-				accounts: {
-					...(cfg.channels?.twitch)?.accounts,
-					[DEFAULT_ACCOUNT_ID]: merged
-				}
-			}
-		}
-	};
-}
-async function noteTwitchSetupHelp(prompter) {
-	await prompter.note([
-		"Twitch requires a bot account with OAuth token.",
-		"1. Create a Twitch application at https://dev.twitch.tv/console",
-		"2. Generate a token with scopes: chat:read and chat:write",
-		"   Use https://twitchtokengenerator.com/ or https://twitchapps.com/tmi/",
-		"3. Copy the token (starts with 'oauth:') and Client ID",
-		"Env vars supported: OPENCLAW_TWITCH_ACCESS_TOKEN",
-		`Docs: ${formatDocsLink("/channels/twitch", "channels/twitch")}`
-	].join("\n"), "Twitch setup");
-}
-async function promptToken(prompter, account, envToken) {
-	const existingToken = account?.accessToken ?? "";
-	if (existingToken && !envToken) {
-		if (await prompter.confirm({
-			message: "Access token already configured. Keep it?",
-			initialValue: true
-		})) return existingToken;
-	}
-	return String(await prompter.text({
-		message: "Twitch OAuth token (oauth:...)",
-		initialValue: envToken ?? "",
-		validate: (value) => {
-			const raw = String(value ?? "").trim();
-			if (!raw) return "Required";
-			if (!raw.startsWith("oauth:")) return "Token should start with 'oauth:'";
-		}
-	})).trim();
-}
-async function promptUsername(prompter, account) {
-	return String(await prompter.text({
-		message: "Twitch bot username",
-		initialValue: account?.username ?? "",
-		validate: (value) => value?.trim() ? void 0 : "Required"
-	})).trim();
-}
-async function promptClientId(prompter, account) {
-	return String(await prompter.text({
-		message: "Twitch Client ID",
-		initialValue: account?.clientId ?? "",
-		validate: (value) => value?.trim() ? void 0 : "Required"
-	})).trim();
-}
-async function promptChannelName(prompter, account) {
-	return String(await prompter.text({
-		message: "Channel to join",
-		initialValue: account?.channel ?? "",
-		validate: (value) => value?.trim() ? void 0 : "Required"
-	})).trim();
-}
-async function promptRefreshTokenSetup(prompter, account) {
-	if (!await prompter.confirm({
-		message: "Enable automatic token refresh (requires client secret and refresh token)?",
-		initialValue: Boolean(account?.clientSecret && account?.refreshToken)
-	})) return {};
-	return {
-		clientSecret: String(await prompter.text({
-			message: "Twitch Client Secret (for token refresh)",
-			initialValue: account?.clientSecret ?? "",
-			validate: (value) => value?.trim() ? void 0 : "Required"
-		})).trim() || void 0,
-		refreshToken: String(await prompter.text({
-			message: "Twitch Refresh Token",
-			initialValue: account?.refreshToken ?? "",
-			validate: (value) => value?.trim() ? void 0 : "Required"
-		})).trim() || void 0
-	};
-}
-async function configureWithEnvToken(cfg, prompter, account, envToken, forceAllowFrom, dmPolicy) {
-	if (!await prompter.confirm({
-		message: "Twitch env var OPENCLAW_TWITCH_ACCESS_TOKEN detected. Use env token?",
-		initialValue: true
-	})) return null;
-	const cfgWithAccount = setTwitchAccount(cfg, {
-		username: await promptUsername(prompter, account),
-		clientId: await promptClientId(prompter, account),
-		accessToken: "",
-		enabled: true
-	});
-	if (forceAllowFrom && dmPolicy.promptAllowFrom) return { cfg: await dmPolicy.promptAllowFrom({
-		cfg: cfgWithAccount,
-		prompter
-	}) };
-	return { cfg: cfgWithAccount };
-}
-function setTwitchAccessControl(cfg, allowedRoles, requireMention) {
-	const account = getAccountConfig(cfg, DEFAULT_ACCOUNT_ID);
-	if (!account) return cfg;
-	return setTwitchAccount(cfg, {
-		...account,
-		allowedRoles,
-		requireMention
-	});
-}
-function resolveTwitchGroupPolicy(cfg) {
-	const account = getAccountConfig(cfg, DEFAULT_ACCOUNT_ID);
-	if (account?.allowedRoles?.includes("all")) return "open";
-	if (account?.allowedRoles?.includes("moderator")) return "allowlist";
-	return "disabled";
-}
-function setTwitchGroupPolicy(cfg, policy) {
-	return setTwitchAccessControl(cfg, policy === "open" ? ["all"] : policy === "allowlist" ? ["moderator", "vip"] : [], true);
-}
-const twitchDmPolicy = {
-	label: "Twitch",
-	channel,
-	policyKey: "channels.twitch.allowedRoles",
-	allowFromKey: "channels.twitch.accounts.default.allowFrom",
-	getCurrent: (cfg) => {
-		const account = getAccountConfig(cfg, DEFAULT_ACCOUNT_ID);
-		if (account?.allowedRoles?.includes("all")) return "open";
-		if (account?.allowFrom && account.allowFrom.length > 0) return "allowlist";
-		return "disabled";
-	},
-	setPolicy: (cfg, policy) => {
-		return setTwitchAccessControl(cfg, policy === "open" ? ["all"] : policy === "allowlist" ? [] : ["moderator"], true);
-	},
-	promptAllowFrom: async ({ cfg, prompter }) => {
-		const account = getAccountConfig(cfg, DEFAULT_ACCOUNT_ID);
-		const existingAllowFrom = account?.allowFrom ?? [];
-		const entry = await prompter.text({
-			message: "Twitch allowFrom (user IDs, one per line, recommended for security)",
-			placeholder: "123456789",
-			initialValue: existingAllowFrom[0] ? String(existingAllowFrom[0]) : void 0
-		});
-		const allowFrom = String(entry ?? "").split(/[\n,;]+/g).map((s) => s.trim()).filter(Boolean);
-		return setTwitchAccount(cfg, {
-			...account ?? void 0,
-			allowFrom
-		});
-	}
-};
-const twitchGroupAccess = {
-	label: "Twitch chat",
-	placeholder: "",
-	skipAllowlistEntries: true,
-	currentPolicy: ({ cfg }) => resolveTwitchGroupPolicy(cfg),
-	currentEntries: ({ cfg }) => {
-		return getAccountConfig(cfg, "default")?.allowFrom ?? [];
-	},
-	updatePrompt: ({ cfg }) => {
-		const account = getAccountConfig(cfg, DEFAULT_ACCOUNT_ID);
-		return Boolean(account?.allowedRoles?.length || account?.allowFrom?.length);
-	},
-	setPolicy: ({ cfg, policy }) => setTwitchGroupPolicy(cfg, policy),
-	resolveAllowlist: async () => [],
-	applyAllowlist: ({ cfg }) => cfg
-};
-const twitchSetupAdapter = {
-	resolveAccountId: () => DEFAULT_ACCOUNT_ID,
-	applyAccountConfig: ({ cfg }) => setTwitchAccount(cfg, { enabled: true })
-};
-const twitchSetupWizard = {
-	channel,
-	resolveAccountIdForConfigure: () => DEFAULT_ACCOUNT_ID,
-	resolveShouldPromptAccountIds: () => false,
-	status: {
-		configuredLabel: "configured",
-		unconfiguredLabel: "needs username, token, and clientId",
-		configuredHint: "configured",
-		unconfiguredHint: "needs setup",
-		resolveConfigured: ({ cfg }) => {
-			const account = getAccountConfig(cfg, DEFAULT_ACCOUNT_ID);
-			return account ? isAccountConfigured(account) : false;
-		},
-		resolveStatusLines: ({ cfg }) => {
-			const account = getAccountConfig(cfg, DEFAULT_ACCOUNT_ID);
-			return [`Twitch: ${(account ? isAccountConfigured(account) : false) ? "configured" : "needs username, token, and clientId"}`];
-		}
-	},
-	credentials: [],
-	finalize: async ({ cfg, prompter, forceAllowFrom }) => {
-		const account = getAccountConfig(cfg, DEFAULT_ACCOUNT_ID);
-		if (!account || !isAccountConfigured(account)) await noteTwitchSetupHelp(prompter);
-		const envToken = process.env.OPENCLAW_TWITCH_ACCESS_TOKEN?.trim();
-		if (envToken && !account?.accessToken) {
-			const envResult = await configureWithEnvToken(cfg, prompter, account, envToken, forceAllowFrom, twitchDmPolicy);
-			if (envResult) return envResult;
-		}
-		const username = await promptUsername(prompter, account);
-		const token = await promptToken(prompter, account, envToken);
-		const clientId = await promptClientId(prompter, account);
-		const channelName = await promptChannelName(prompter, account);
-		const { clientSecret, refreshToken } = await promptRefreshTokenSetup(prompter, account);
-		const cfgWithAccount = setTwitchAccount(cfg, {
-			username,
-			accessToken: token,
-			clientId,
-			channel: channelName,
-			clientSecret,
-			refreshToken,
-			enabled: true
-		});
-		return { cfg: forceAllowFrom && twitchDmPolicy.promptAllowFrom ? await twitchDmPolicy.promptAllowFrom({
-			cfg: cfgWithAccount,
-			prompter
-		}) : cfgWithAccount };
-	},
-	dmPolicy: twitchDmPolicy,
-	groupAccess: twitchGroupAccess,
-	disable: (cfg) => {
-		const twitch = cfg.channels?.twitch;
-		return {
-			...cfg,
-			channels: {
-				...cfg.channels,
-				twitch: {
-					...twitch,
-					enabled: false
-				}
-			}
-		};
-	}
-};
-//#endregion
-//#region extensions/twitch/src/status.ts
-/**
-* Collect status issues for Twitch accounts.
-*
-* Analyzes account snapshots and detects configuration problems,
-* authentication issues, and other potential problems.
-*
-* @param accounts - Array of account snapshots to analyze
-* @param getCfg - Optional function to get full config for additional checks
-* @returns Array of detected status issues
-*
-* @example
-* const issues = collectTwitchStatusIssues(accountSnapshots);
-* if (issues.length > 0) {
-*   console.warn("Twitch configuration issues detected:");
-*   issues.forEach(issue => console.warn(`- ${issue.message}`));
-* }
-*/
-function collectTwitchStatusIssues(accounts, getCfg) {
-	const issues = [];
-	for (const entry of accounts) {
-		const accountId = entry.accountId;
-		if (!accountId) continue;
-		let account = null;
-		let cfg;
-		if (getCfg) try {
-			cfg = getCfg();
-			account = getAccountConfig(cfg, accountId);
-		} catch {}
-		if (!entry.configured) {
-			issues.push({
-				channel: "twitch",
-				accountId,
-				kind: "config",
-				message: "Twitch account is not properly configured",
-				fix: "Add required fields: username, accessToken, and clientId to your account configuration"
-			});
-			continue;
-		}
-		if (entry.enabled === false) {
-			issues.push({
-				channel: "twitch",
-				accountId,
-				kind: "config",
-				message: "Twitch account is disabled",
-				fix: "Set enabled: true in your account configuration to enable this account"
-			});
-			continue;
-		}
-		if (account && account.username && account.accessToken && !account.clientId) issues.push({
-			channel: "twitch",
-			accountId,
-			kind: "config",
-			message: "Twitch client ID is required",
-			fix: "Add clientId to your Twitch account configuration (from Twitch Developer Portal)"
-		});
-		const tokenResolution = cfg ? resolveTwitchToken(cfg, { accountId }) : {
-			token: "",
-			source: "none"
-		};
-		if (account && isAccountConfigured(account, tokenResolution.token)) {
-			if (account.accessToken?.startsWith("oauth:")) issues.push({
-				channel: "twitch",
-				accountId,
-				kind: "config",
-				message: "Token contains 'oauth:' prefix (will be stripped)",
-				fix: "The 'oauth:' prefix is optional. You can use just the token value, or keep it as-is (it will be normalized automatically)."
-			});
-			if (account.clientSecret && !account.refreshToken) issues.push({
-				channel: "twitch",
-				accountId,
-				kind: "config",
-				message: "clientSecret provided without refreshToken",
-				fix: "For automatic token refresh, provide both clientSecret and refreshToken. Otherwise, clientSecret is not needed."
-			});
-			if (account.allowFrom && account.allowFrom.length === 0) issues.push({
-				channel: "twitch",
-				accountId,
-				kind: "config",
-				message: "allowFrom is configured but empty",
-				fix: "Either add user IDs to allowFrom, remove the allowFrom field, or use allowedRoles instead."
-			});
-			if (account.allowedRoles?.includes("all") && account.allowFrom && account.allowFrom.length > 0) issues.push({
-				channel: "twitch",
-				accountId,
-				kind: "intent",
-				message: "allowedRoles is set to 'all' but allowFrom is also configured",
-				fix: "When allowedRoles is 'all', the allowFrom list is not needed. Remove allowFrom or set allowedRoles to specific roles."
-			});
-		}
-		if (entry.lastError) issues.push({
-			channel: "twitch",
-			accountId,
-			kind: "runtime",
-			message: `Last error: ${entry.lastError}`,
-			fix: "Check your token validity and network connection. Ensure the bot has the required OAuth scopes."
-		});
-		if (entry.configured && !entry.running && !entry.lastStartAt && !entry.lastInboundAt && !entry.lastOutboundAt) issues.push({
-			channel: "twitch",
-			accountId,
-			kind: "runtime",
-			message: "Account has never connected successfully",
-			fix: "Start the Twitch gateway to begin receiving messages. Check logs for connection errors."
-		});
-		if (entry.running && entry.lastStartAt) {
-			const daysSinceStart = (Date.now() - entry.lastStartAt) / (1e3 * 60 * 60 * 24);
-			if (daysSinceStart > 7) issues.push({
-				channel: "twitch",
-				accountId,
-				kind: "runtime",
-				message: `Connection has been running for ${Math.floor(daysSinceStart)} days`,
-				fix: "Consider restarting the connection periodically to refresh the connection. Twitch tokens may expire after long periods."
-			});
-		}
-	}
-	return issues;
-}
-//#endregion
-//#region extensions/twitch/index.ts
-var twitch_default = defineChannelPluginEntry({
-	id: "twitch",
-	name: "Twitch",
-	description: "Twitch chat channel plugin",
-	plugin: createChatChannelPlugin({
-		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) => listAccountIds(cfg),
-				resolveAccount: (cfg, accountId) => {
-					const resolvedAccountId = accountId ?? "default";
-					const account = getAccountConfig(cfg, resolvedAccountId);
-					if (!account) return {
-						accountId: resolvedAccountId,
-						channel: "",
-						username: "",
-						accessToken: "",
-						clientId: "",
-						enabled: false
-					};
-					return {
-						accountId: resolvedAccountId,
-						...account
-					};
-				},
-				defaultAccountId: () => DEFAULT_ACCOUNT_ID,
-				isConfigured: (_account, cfg) => resolveTwitchAccountContext(cfg, DEFAULT_ACCOUNT_ID).configured,
-				isEnabled: (account) => account?.enabled !== false,
-				describeAccount: (account) => 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 }) => {
-				const account = getAccountConfig(cfg, accountId ?? "default");
-				if (!account) return inputs.map((input) => ({
-					input,
-					resolved: false,
-					note: "account not configured"
-				}));
-				return await resolveTwitchTargets(inputs, account, kind, {
-					info: (msg) => runtime.log(msg),
-					warn: (msg) => runtime.log(msg),
-					error: (msg) => runtime.error(msg),
-					debug: (msg) => runtime.log(msg)
-				});
-			} },
-			status: createComputedAccountStatusAdapter({
-				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) => {
-					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}`);
-					const { monitorTwitchProvider } = await import("../../monitor-DZmBV1Nj2.js");
-					await monitorTwitchProvider({
-						account,
-						accountId,
-						config: ctx.cfg,
-						runtime: ctx.runtime,
-						abortSignal: ctx.abortSignal
-					});
-				},
-				stopAccount: async (ctx) => {
-					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}`);
-				}
-			}
-		}
-	}),
-	setRuntime: setTwitchRuntime
-});
-//#endregion
-export { twitch_default as default, monitorTwitchProvider };