loudmouth-ai 0.1.0 → 0.2.0

package/extensions/twitch/src/access-control.test.ts

@@ -1,489 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { checkTwitchAccessControl, extractMentions } from "./access-control.js";
-import type { TwitchAccountConfig, TwitchChatMessage } from "./types.js";
-
-describe("checkTwitchAccessControl", () => {
-  const mockAccount: TwitchAccountConfig = {
-    username: "testbot",
-    token: "oauth:test",
-  };
-
-  const mockMessage: TwitchChatMessage = {
-    username: "testuser",
-    userId: "123456",
-    message: "hello bot",
-    channel: "testchannel",
-  };
-
-  describe("when no restrictions are configured", () => {
-    it("allows messages that mention the bot (default requireMention)", () => {
-      const message: TwitchChatMessage = {
-        ...mockMessage,
-        message: "@testbot hello",
-      };
-      const result = checkTwitchAccessControl({
-        message,
-        account: mockAccount,
-        botUsername: "testbot",
-      });
-      expect(result.allowed).toBe(true);
-    });
-  });
-
-  describe("requireMention default", () => {
-    it("defaults to true when undefined", () => {
-      const message: TwitchChatMessage = {
-        ...mockMessage,
-        message: "hello bot",
-      };
-
-      const result = checkTwitchAccessControl({
-        message,
-        account: mockAccount,
-        botUsername: "testbot",
-      });
-      expect(result.allowed).toBe(false);
-      expect(result.reason).toContain("does not mention the bot");
-    });
-
-    it("allows mention when requireMention is undefined", () => {
-      const message: TwitchChatMessage = {
-        ...mockMessage,
-        message: "@testbot hello",
-      };
-
-      const result = checkTwitchAccessControl({
-        message,
-        account: mockAccount,
-        botUsername: "testbot",
-      });
-      expect(result.allowed).toBe(true);
-    });
-  });
-
-  describe("requireMention", () => {
-    it("allows messages that mention the bot", () => {
-      const account: TwitchAccountConfig = {
-        ...mockAccount,
-        requireMention: true,
-      };
-      const message: TwitchChatMessage = {
-        ...mockMessage,
-        message: "@testbot hello",
-      };
-
-      const result = checkTwitchAccessControl({
-        message,
-        account,
-        botUsername: "testbot",
-      });
-      expect(result.allowed).toBe(true);
-    });
-
-    it("blocks messages that don't mention the bot", () => {
-      const account: TwitchAccountConfig = {
-        ...mockAccount,
-        requireMention: true,
-      };
-
-      const result = checkTwitchAccessControl({
-        message: mockMessage,
-        account,
-        botUsername: "testbot",
-      });
-      expect(result.allowed).toBe(false);
-      expect(result.reason).toContain("does not mention the bot");
-    });
-
-    it("is case-insensitive for bot username", () => {
-      const account: TwitchAccountConfig = {
-        ...mockAccount,
-        requireMention: true,
-      };
-      const message: TwitchChatMessage = {
-        ...mockMessage,
-        message: "@TestBot hello",
-      };
-
-      const result = checkTwitchAccessControl({
-        message,
-        account,
-        botUsername: "testbot",
-      });
-      expect(result.allowed).toBe(true);
-    });
-  });
-
-  describe("allowFrom allowlist", () => {
-    it("allows users in the allowlist", () => {
-      const account: TwitchAccountConfig = {
-        ...mockAccount,
-        allowFrom: ["123456", "789012"],
-      };
-      const message: TwitchChatMessage = {
-        ...mockMessage,
-        message: "@testbot hello",
-      };
-
-      const result = checkTwitchAccessControl({
-        message,
-        account,
-        botUsername: "testbot",
-      });
-      expect(result.allowed).toBe(true);
-      expect(result.matchKey).toBe("123456");
-      expect(result.matchSource).toBe("allowlist");
-    });
-
-    it("allows users not in allowlist via fallback (open access)", () => {
-      const account: TwitchAccountConfig = {
-        ...mockAccount,
-        allowFrom: ["789012"],
-      };
-      const message: TwitchChatMessage = {
-        ...mockMessage,
-        message: "@testbot hello",
-      };
-
-      const result = checkTwitchAccessControl({
-        message,
-        account,
-        botUsername: "testbot",
-      });
-      // Falls through to final fallback since allowedRoles is not set
-      expect(result.allowed).toBe(true);
-    });
-
-    it("blocks messages without userId", () => {
-      const account: TwitchAccountConfig = {
-        ...mockAccount,
-        allowFrom: ["123456"],
-      };
-      const message: TwitchChatMessage = {
-        ...mockMessage,
-        message: "@testbot hello",
-        userId: undefined,
-      };
-
-      const result = checkTwitchAccessControl({
-        message,
-        account,
-        botUsername: "testbot",
-      });
-      expect(result.allowed).toBe(false);
-      expect(result.reason).toContain("user ID not available");
-    });
-
-    it("bypasses role checks when user is in allowlist", () => {
-      const account: TwitchAccountConfig = {
-        ...mockAccount,
-        allowFrom: ["123456"],
-        allowedRoles: ["owner"],
-      };
-      const message: TwitchChatMessage = {
-        ...mockMessage,
-        message: "@testbot hello",
-        isOwner: false,
-      };
-
-      const result = checkTwitchAccessControl({
-        message,
-        account,
-        botUsername: "testbot",
-      });
-      expect(result.allowed).toBe(true);
-    });
-
-    it("allows user with role even if not in allowlist", () => {
-      const account: TwitchAccountConfig = {
-        ...mockAccount,
-        allowFrom: ["789012"],
-        allowedRoles: ["moderator"],
-      };
-      const message: TwitchChatMessage = {
-        ...mockMessage,
-        message: "@testbot hello",
-        userId: "123456",
-        isMod: true,
-      };
-
-      const result = checkTwitchAccessControl({
-        message,
-        account,
-        botUsername: "testbot",
-      });
-      expect(result.allowed).toBe(true);
-      expect(result.matchSource).toBe("role");
-    });
-
-    it("blocks user with neither allowlist nor role", () => {
-      const account: TwitchAccountConfig = {
-        ...mockAccount,
-        allowFrom: ["789012"],
-        allowedRoles: ["moderator"],
-      };
-      const message: TwitchChatMessage = {
-        ...mockMessage,
-        message: "@testbot hello",
-        userId: "123456",
-        isMod: false,
-      };
-
-      const result = checkTwitchAccessControl({
-        message,
-        account,
-        botUsername: "testbot",
-      });
-      expect(result.allowed).toBe(false);
-      expect(result.reason).toContain("does not have any of the required roles");
-    });
-  });
-
-  describe("allowedRoles", () => {
-    it("allows users with matching role", () => {
-      const account: TwitchAccountConfig = {
-        ...mockAccount,
-        allowedRoles: ["moderator"],
-      };
-      const message: TwitchChatMessage = {
-        ...mockMessage,
-        message: "@testbot hello",
-        isMod: true,
-      };
-
-      const result = checkTwitchAccessControl({
-        message,
-        account,
-        botUsername: "testbot",
-      });
-      expect(result.allowed).toBe(true);
-      expect(result.matchSource).toBe("role");
-    });
-
-    it("allows users with any of multiple roles", () => {
-      const account: TwitchAccountConfig = {
-        ...mockAccount,
-        allowedRoles: ["moderator", "vip", "subscriber"],
-      };
-      const message: TwitchChatMessage = {
-        ...mockMessage,
-        message: "@testbot hello",
-        isVip: true,
-        isMod: false,
-        isSub: false,
-      };
-
-      const result = checkTwitchAccessControl({
-        message,
-        account,
-        botUsername: "testbot",
-      });
-      expect(result.allowed).toBe(true);
-    });
-
-    it("blocks users without matching role", () => {
-      const account: TwitchAccountConfig = {
-        ...mockAccount,
-        allowedRoles: ["moderator"],
-      };
-      const message: TwitchChatMessage = {
-        ...mockMessage,
-        message: "@testbot hello",
-        isMod: false,
-      };
-
-      const result = checkTwitchAccessControl({
-        message,
-        account,
-        botUsername: "testbot",
-      });
-      expect(result.allowed).toBe(false);
-      expect(result.reason).toContain("does not have any of the required roles");
-    });
-
-    it("allows all users when role is 'all'", () => {
-      const account: TwitchAccountConfig = {
-        ...mockAccount,
-        allowedRoles: ["all"],
-      };
-      const message: TwitchChatMessage = {
-        ...mockMessage,
-        message: "@testbot hello",
-      };
-
-      const result = checkTwitchAccessControl({
-        message,
-        account,
-        botUsername: "testbot",
-      });
-      expect(result.allowed).toBe(true);
-      expect(result.matchKey).toBe("all");
-    });
-
-    it("handles moderator role", () => {
-      const account: TwitchAccountConfig = {
-        ...mockAccount,
-        allowedRoles: ["moderator"],
-      };
-      const message: TwitchChatMessage = {
-        ...mockMessage,
-        message: "@testbot hello",
-        isMod: true,
-      };
-
-      const result = checkTwitchAccessControl({
-        message,
-        account,
-        botUsername: "testbot",
-      });
-      expect(result.allowed).toBe(true);
-    });
-
-    it("handles subscriber role", () => {
-      const account: TwitchAccountConfig = {
-        ...mockAccount,
-        allowedRoles: ["subscriber"],
-      };
-      const message: TwitchChatMessage = {
-        ...mockMessage,
-        message: "@testbot hello",
-        isSub: true,
-      };
-
-      const result = checkTwitchAccessControl({
-        message,
-        account,
-        botUsername: "testbot",
-      });
-      expect(result.allowed).toBe(true);
-    });
-
-    it("handles owner role", () => {
-      const account: TwitchAccountConfig = {
-        ...mockAccount,
-        allowedRoles: ["owner"],
-      };
-      const message: TwitchChatMessage = {
-        ...mockMessage,
-        message: "@testbot hello",
-        isOwner: true,
-      };
-
-      const result = checkTwitchAccessControl({
-        message,
-        account,
-        botUsername: "testbot",
-      });
-      expect(result.allowed).toBe(true);
-    });
-
-    it("handles vip role", () => {
-      const account: TwitchAccountConfig = {
-        ...mockAccount,
-        allowedRoles: ["vip"],
-      };
-      const message: TwitchChatMessage = {
-        ...mockMessage,
-        message: "@testbot hello",
-        isVip: true,
-      };
-
-      const result = checkTwitchAccessControl({
-        message,
-        account,
-        botUsername: "testbot",
-      });
-      expect(result.allowed).toBe(true);
-    });
-  });
-
-  describe("combined restrictions", () => {
-    it("checks requireMention before allowlist", () => {
-      const account: TwitchAccountConfig = {
-        ...mockAccount,
-        requireMention: true,
-        allowFrom: ["123456"],
-      };
-      const message: TwitchChatMessage = {
-        ...mockMessage,
-        message: "hello", // No mention
-      };
-
-      const result = checkTwitchAccessControl({
-        message,
-        account,
-        botUsername: "testbot",
-      });
-      expect(result.allowed).toBe(false);
-      expect(result.reason).toContain("does not mention the bot");
-    });
-
-    it("checks allowlist before allowedRoles", () => {
-      const account: TwitchAccountConfig = {
-        ...mockAccount,
-        allowFrom: ["123456"],
-        allowedRoles: ["owner"],
-      };
-      const message: TwitchChatMessage = {
-        ...mockMessage,
-        message: "@testbot hello",
-        isOwner: false,
-      };
-
-      const result = checkTwitchAccessControl({
-        message,
-        account,
-        botUsername: "testbot",
-      });
-      expect(result.allowed).toBe(true);
-      expect(result.matchSource).toBe("allowlist");
-    });
-  });
-});
-
-describe("extractMentions", () => {
-  it("extracts single mention", () => {
-    const mentions = extractMentions("hello @testbot");
-    expect(mentions).toEqual(["testbot"]);
-  });
-
-  it("extracts multiple mentions", () => {
-    const mentions = extractMentions("hello @testbot and @otheruser");
-    expect(mentions).toEqual(["testbot", "otheruser"]);
-  });
-
-  it("returns empty array when no mentions", () => {
-    const mentions = extractMentions("hello everyone");
-    expect(mentions).toEqual([]);
-  });
-
-  it("handles mentions at start of message", () => {
-    const mentions = extractMentions("@testbot hello");
-    expect(mentions).toEqual(["testbot"]);
-  });
-
-  it("handles mentions at end of message", () => {
-    const mentions = extractMentions("hello @testbot");
-    expect(mentions).toEqual(["testbot"]);
-  });
-
-  it("converts mentions to lowercase", () => {
-    const mentions = extractMentions("hello @TestBot");
-    expect(mentions).toEqual(["testbot"]);
-  });
-
-  it("extracts alphanumeric usernames", () => {
-    const mentions = extractMentions("hello @user123");
-    expect(mentions).toEqual(["user123"]);
-  });
-
-  it("handles underscores in usernames", () => {
-    const mentions = extractMentions("hello @test_user");
-    expect(mentions).toEqual(["test_user"]);
-  });
-
-  it("handles empty string", () => {
-    const mentions = extractMentions("");
-    expect(mentions).toEqual([]);
-  });
-});

package/extensions/twitch/src/access-control.ts

@@ -1,154 +0,0 @@
-import type { TwitchAccountConfig, TwitchChatMessage } from "./types.js";
-
-/**
- * Result of checking access control for a Twitch message
- */
-export type TwitchAccessControlResult = {
-  allowed: boolean;
-  reason?: string;
-  matchKey?: string;
-  matchSource?: string;
-};
-
-/**
- * Check if a Twitch message should be allowed based on account configuration
- *
- * This function implements the access control logic for incoming Twitch messages,
- * checking allowlists, role-based restrictions, and mention requirements.
- *
- * Priority order:
- * 1. If `requireMention` is true, message must mention the bot
- * 2. If `allowFrom` is set, sender must be in the allowlist (by user ID)
- * 3. If `allowedRoles` is set, sender must have at least one of the specified roles
- *
- * Note: You can combine `allowFrom` with `allowedRoles`. If a user is in `allowFrom`,
- * they bypass role checks. This is useful for allowing specific users regardless of role.
- *
- * Available roles:
- * - "moderator": Moderators
- * - "owner": Channel owner/broadcaster
- * - "vip": VIPs
- * - "subscriber": Subscribers
- * - "all": Anyone in the chat
- */
-export function checkTwitchAccessControl(params: {
-  message: TwitchChatMessage;
-  account: TwitchAccountConfig;
-  botUsername: string;
-}): TwitchAccessControlResult {
-  const { message, account, botUsername } = params;
-
-  if (account.requireMention ?? true) {
-    const mentions = extractMentions(message.message);
-    if (!mentions.includes(botUsername.toLowerCase())) {
-      return {
-        allowed: false,
-        reason: "message does not mention the bot (requireMention is enabled)",
-      };
-    }
-  }
-
-  if (account.allowFrom && account.allowFrom.length > 0) {
-    const allowFrom = account.allowFrom;
-    const senderId = message.userId;
-
-    if (!senderId) {
-      return {
-        allowed: false,
-        reason: "sender user ID not available for allowlist check",
-      };
-    }
-
-    if (allowFrom.includes(senderId)) {
-      return {
-        allowed: true,
-        matchKey: senderId,
-        matchSource: "allowlist",
-      };
-    }
-  }
-
-  if (account.allowedRoles && account.allowedRoles.length > 0) {
-    const allowedRoles = account.allowedRoles;
-
-    // "all" grants access to everyone
-    if (allowedRoles.includes("all")) {
-      return {
-        allowed: true,
-        matchKey: "all",
-        matchSource: "role",
-      };
-    }
-
-    const hasAllowedRole = checkSenderRoles({
-      message,
-      allowedRoles,
-    });
-
-    if (!hasAllowedRole) {
-      return {
-        allowed: false,
-        reason: `sender does not have any of the required roles: ${allowedRoles.join(", ")}`,
-      };
-    }
-
-    return {
-      allowed: true,
-      matchKey: allowedRoles.join(","),
-      matchSource: "role",
-    };
-  }
-
-  return {
-    allowed: true,
-  };
-}
-
-/**
- * Check if the sender has any of the allowed roles
- */
-function checkSenderRoles(params: { message: TwitchChatMessage; allowedRoles: string[] }): boolean {
-  const { message, allowedRoles } = params;
-  const { isMod, isOwner, isVip, isSub } = message;
-
-  for (const role of allowedRoles) {
-    switch (role) {
-      case "moderator":
-        if (isMod) return true;
-        break;
-      case "owner":
-        if (isOwner) return true;
-        break;
-      case "vip":
-        if (isVip) return true;
-        break;
-      case "subscriber":
-        if (isSub) return true;
-        break;
-    }
-  }
-
-  return false;
-}
-
-/**
- * Extract @mentions from a Twitch chat message
- *
- * Returns a list of lowercase usernames that were mentioned in the message.
- * Twitch mentions are in the format @username.
- */
-export function extractMentions(message: string): string[] {
-  const mentionRegex = /@(\w+)/g;
-  const mentions: string[] = [];
-  let match: RegExpExecArray | null;
-
-  // biome-ignore lint/suspicious/noAssignInExpressions: Standard regex iteration pattern
-  while ((match = mentionRegex.exec(message)) !== null) {
-    const username = match[1];
-    if (username) {
-      mentions.push(username.toLowerCase());
-    }
-  }
-
-  return mentions;
-}