@gakr-gakr/twitch 0.1.0

package/src/resolver.ts

@@ -0,0 +1,139 @@
+/**
+ * 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.
+ */
+
+import { ApiClient } from "@twurple/api";
+import { StaticAuthProvider } from "@twurple/auth";
+import { formatErrorMessage } from "autobot/plugin-sdk/error-runtime";
+import { normalizeLowercaseStringOrEmpty } from "autobot/plugin-sdk/string-coerce-runtime";
+import type { ChannelResolveKind, ChannelResolveResult } from "./types.js";
+import type { ChannelLogSink, TwitchAccountConfig } from "./types.js";
+import { normalizeToken } from "./utils/twitch.js";
+
+/**
+ * Normalize a Twitch username - strip @ prefix and convert to lowercase
+ */
+function normalizeUsername(input: string): string {
+  const trimmed = input.trim();
+  if (trimmed.startsWith("@")) {
+    return normalizeLowercaseStringOrEmpty(trimmed.slice(1));
+  }
+  return normalizeLowercaseStringOrEmpty(trimmed);
+}
+
+/**
+ * Create a logger that includes the Twitch prefix
+ */
+function createLogger(logger?: ChannelLogSink): ChannelLogSink {
+  return {
+    info: (msg: string) => logger?.info(msg),
+    warn: (msg: string) => logger?.warn(msg),
+    error: (msg: string) => logger?.error(msg),
+    debug: (msg: string) => 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
+ */
+export async function resolveTwitchTargets(
+  inputs: string[],
+  account: TwitchAccountConfig,
+  _kind: ChannelResolveKind,
+  logger?: ChannelLogSink,
+): Promise<ChannelResolveResult[]> {
+  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 authProvider = new StaticAuthProvider(account.clientId, normalizedToken);
+  const apiClient = new ApiClient({ authProvider });
+
+  const results: ChannelResolveResult[] = [];
+
+  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}` : undefined,
+          });
+          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 = formatErrorMessage(error);
+      results.push({
+        input,
+        resolved: false,
+        note: `API error: ${errorMessage}`,
+      });
+      log.error(`Failed to resolve ${input}: ${errorMessage}`);
+    }
+  }
+
+  return results;
+}

package/src/runtime.ts

@@ -0,0 +1,9 @@
+import type { PluginRuntime } from "autobot/plugin-sdk/core";
+import { createPluginRuntimeStore } from "autobot/plugin-sdk/runtime-store";
+
+const { setRuntime: setTwitchRuntime, getRuntime: getTwitchRuntime } =
+  createPluginRuntimeStore<PluginRuntime>({
+    pluginId: "twitch",
+    errorMessage: "Twitch runtime not initialized",
+  });
+export { getTwitchRuntime, setTwitchRuntime };

package/src/send.ts

@@ -0,0 +1,191 @@
+/**
+ * Twitch message sending functions with dependency injection support.
+ *
+ * These functions are the primary interface for sending messages to Twitch.
+ * They support dependency injection via the `deps` parameter for testability.
+ */
+
+import {
+  createMessageReceiptFromOutboundResults,
+  type MessageReceipt,
+} from "autobot/plugin-sdk/channel-message";
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import { formatErrorMessage } from "autobot/plugin-sdk/error-runtime";
+import { getClientManager as getRegistryClientManager } from "./client-manager-registry.js";
+import { resolveTwitchAccountContext } from "./config.js";
+import { stripMarkdownForTwitch } from "./utils/markdown.js";
+import { generateMessageId, normalizeTwitchChannel } from "./utils/twitch.js";
+
+/**
+ * Result from sending a message to Twitch.
+ */
+export interface SendMessageResult {
+  /** Whether the send was successful */
+  ok: boolean;
+  /** The message ID (generated for tracking) */
+  messageId: string;
+  /** Receipt for visible sends; empty when no Twitch message was sent */
+  receipt: MessageReceipt;
+  /** Error message if the send failed */
+  error?: string;
+}
+
+function createTwitchSendReceipt(params: {
+  messageId: string;
+  channel?: string | null;
+  visible?: boolean;
+}): MessageReceipt {
+  const messageId = params.messageId.trim();
+  const conversationId = params.channel?.trim();
+  const hasVisibleMessage = params.visible === true && messageId && messageId !== "skipped";
+  return createMessageReceiptFromOutboundResults({
+    results: hasVisibleMessage
+      ? [
+          {
+            channel: "twitch",
+            messageId,
+            ...(conversationId ? { conversationId } : {}),
+          },
+        ]
+      : [],
+    kind: "text",
+  });
+}
+
+/**
+ * Internal send function used by the outbound adapter.
+ *
+ * This function has access to the full AutoBot config and handles
+ * account resolution, markdown stripping, and actual message sending.
+ *
+ * @param channel - The channel name
+ * @param text - The message text
+ * @param cfg - Full AutoBot 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!",
+ *   autobotConfig,
+ *   "default",
+ *   true,
+ *   console,
+ * );
+ */
+export async function sendMessageTwitchInternal(
+  channel: string,
+  text: string,
+  cfg: AutoBotConfig,
+  accountId?: string,
+  stripMarkdown: boolean = true,
+  logger: Console = console,
+): Promise<SendMessageResult> {
+  const {
+    account,
+    configured,
+    availableAccountIds,
+    accountId: resolvedAccountId,
+  } = resolveTwitchAccountContext(cfg, accountId);
+  if (!account) {
+    return {
+      ok: false,
+      messageId: generateMessageId(),
+      receipt: createTwitchSendReceipt({ messageId: "", channel, visible: false }),
+      error: `Account not found: ${accountId ?? "(default)"}. Available accounts: ${availableAccountIds.join(", ") || "none"}`,
+    };
+  }
+
+  if (!configured) {
+    return {
+      ok: false,
+      messageId: generateMessageId(),
+      receipt: createTwitchSendReceipt({ messageId: "", channel, visible: false }),
+      error:
+        `Account ${resolvedAccountId} 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(),
+      receipt: createTwitchSendReceipt({
+        messageId: "",
+        channel: normalizedChannel,
+        visible: false,
+      }),
+      error: "No channel specified and no default channel in account config",
+    };
+  }
+  const deliveryChannel = normalizeTwitchChannel(normalizedChannel);
+
+  const cleanedText = stripMarkdown ? stripMarkdownForTwitch(text) : text;
+  if (!cleanedText) {
+    return {
+      ok: true,
+      messageId: "skipped",
+      receipt: createTwitchSendReceipt({
+        messageId: "skipped",
+        channel: deliveryChannel,
+        visible: false,
+      }),
+    };
+  }
+
+  const clientManager = getRegistryClientManager(resolvedAccountId);
+  if (!clientManager) {
+    return {
+      ok: false,
+      messageId: generateMessageId(),
+      receipt: createTwitchSendReceipt({
+        messageId: "",
+        channel: deliveryChannel,
+        visible: false,
+      }),
+      error: `Client manager not found for account: ${resolvedAccountId}. Please start the Twitch gateway first.`,
+    };
+  }
+
+  try {
+    const result = await clientManager.sendMessage(
+      account,
+      deliveryChannel,
+      cleanedText,
+      cfg,
+      resolvedAccountId,
+    );
+
+    if (!result.ok) {
+      const messageId = result.messageId ?? generateMessageId();
+      return {
+        ok: false,
+        messageId,
+        receipt: createTwitchSendReceipt({ messageId, channel: deliveryChannel, visible: false }),
+        error: result.error ?? "Send failed",
+      };
+    }
+
+    const messageId = result.messageId ?? generateMessageId();
+    return {
+      ok: true,
+      messageId,
+      receipt: createTwitchSendReceipt({ messageId, channel: deliveryChannel, visible: true }),
+    };
+  } catch (error) {
+    const errorMsg = formatErrorMessage(error);
+    const messageId = generateMessageId();
+    logger.error(`Failed to send message: ${errorMsg}`);
+    return {
+      ok: false,
+      messageId,
+      receipt: createTwitchSendReceipt({ messageId, channel: deliveryChannel, visible: false }),
+      error: errorMsg,
+    };
+  }
+}