loudmouth-ai 0.1.0 → 0.2.0

package/extensions/twitch/src/status.test.ts

@@ -1,270 +0,0 @@
-/**
- * Tests for status.ts module
- *
- * Tests cover:
- * - Detection of unconfigured accounts
- * - Detection of disabled accounts
- * - Detection of missing clientId
- * - Token format warnings
- * - Access control warnings
- * - Runtime error detection
- */
-
-import { describe, expect, it } from "vitest";
-import { collectTwitchStatusIssues } from "./status.js";
-import type { ChannelAccountSnapshot } from "./types.js";
-
-describe("status", () => {
-  describe("collectTwitchStatusIssues", () => {
-    it("should detect unconfigured accounts", () => {
-      const snapshots: ChannelAccountSnapshot[] = [
-        {
-          accountId: "default",
-          configured: false,
-          enabled: true,
-          running: false,
-        },
-      ];
-
-      const issues = collectTwitchStatusIssues(snapshots);
-
-      expect(issues.length).toBeGreaterThan(0);
-      expect(issues[0]?.kind).toBe("config");
-      expect(issues[0]?.message).toContain("not properly configured");
-    });
-
-    it("should detect disabled accounts", () => {
-      const snapshots: ChannelAccountSnapshot[] = [
-        {
-          accountId: "default",
-          configured: true,
-          enabled: false,
-          running: false,
-        },
-      ];
-
-      const issues = collectTwitchStatusIssues(snapshots);
-
-      expect(issues.length).toBeGreaterThan(0);
-      const disabledIssue = issues.find((i) => i.message.includes("disabled"));
-      expect(disabledIssue).toBeDefined();
-    });
-
-    it("should detect missing clientId when account configured (simplified config)", () => {
-      const snapshots: ChannelAccountSnapshot[] = [
-        {
-          accountId: "default",
-          configured: true,
-          enabled: true,
-          running: false,
-        },
-      ];
-
-      const mockCfg = {
-        channels: {
-          twitch: {
-            username: "testbot",
-            accessToken: "oauth:test123",
-            // clientId missing
-          },
-        },
-      };
-
-      const issues = collectTwitchStatusIssues(snapshots, () => mockCfg as never);
-
-      const clientIdIssue = issues.find((i) => i.message.includes("client ID"));
-      expect(clientIdIssue).toBeDefined();
-    });
-
-    it("should warn about oauth: prefix in token (simplified config)", () => {
-      const snapshots: ChannelAccountSnapshot[] = [
-        {
-          accountId: "default",
-          configured: true,
-          enabled: true,
-          running: false,
-        },
-      ];
-
-      const mockCfg = {
-        channels: {
-          twitch: {
-            username: "testbot",
-            accessToken: "oauth:test123", // has prefix
-            clientId: "test-id",
-          },
-        },
-      };
-
-      const issues = collectTwitchStatusIssues(snapshots, () => mockCfg as never);
-
-      const prefixIssue = issues.find((i) => i.message.includes("oauth:"));
-      expect(prefixIssue).toBeDefined();
-      expect(prefixIssue?.kind).toBe("config");
-    });
-
-    it("should detect clientSecret without refreshToken (simplified config)", () => {
-      const snapshots: ChannelAccountSnapshot[] = [
-        {
-          accountId: "default",
-          configured: true,
-          enabled: true,
-          running: false,
-        },
-      ];
-
-      const mockCfg = {
-        channels: {
-          twitch: {
-            username: "testbot",
-            accessToken: "oauth:test123",
-            clientId: "test-id",
-            clientSecret: "secret123",
-            // refreshToken missing
-          },
-        },
-      };
-
-      const issues = collectTwitchStatusIssues(snapshots, () => mockCfg as never);
-
-      const secretIssue = issues.find((i) => i.message.includes("clientSecret"));
-      expect(secretIssue).toBeDefined();
-    });
-
-    it("should detect empty allowFrom array (simplified config)", () => {
-      const snapshots: ChannelAccountSnapshot[] = [
-        {
-          accountId: "default",
-          configured: true,
-          enabled: true,
-          running: false,
-        },
-      ];
-
-      const mockCfg = {
-        channels: {
-          twitch: {
-            username: "testbot",
-            accessToken: "test123",
-            clientId: "test-id",
-            allowFrom: [], // empty array
-          },
-        },
-      };
-
-      const issues = collectTwitchStatusIssues(snapshots, () => mockCfg as never);
-
-      const allowFromIssue = issues.find((i) => i.message.includes("allowFrom"));
-      expect(allowFromIssue).toBeDefined();
-    });
-
-    it("should detect allowedRoles 'all' with allowFrom conflict (simplified config)", () => {
-      const snapshots: ChannelAccountSnapshot[] = [
-        {
-          accountId: "default",
-          configured: true,
-          enabled: true,
-          running: false,
-        },
-      ];
-
-      const mockCfg = {
-        channels: {
-          twitch: {
-            username: "testbot",
-            accessToken: "test123",
-            clientId: "test-id",
-            allowedRoles: ["all"],
-            allowFrom: ["123456"], // conflict!
-          },
-        },
-      };
-
-      const issues = collectTwitchStatusIssues(snapshots, () => mockCfg as never);
-
-      const conflictIssue = issues.find((i) => i.kind === "intent");
-      expect(conflictIssue).toBeDefined();
-      expect(conflictIssue?.message).toContain("allowedRoles is set to 'all'");
-    });
-
-    it("should detect runtime errors", () => {
-      const snapshots: ChannelAccountSnapshot[] = [
-        {
-          accountId: "default",
-          configured: true,
-          enabled: true,
-          running: false,
-          lastError: "Connection timeout",
-        },
-      ];
-
-      const issues = collectTwitchStatusIssues(snapshots);
-
-      const runtimeIssue = issues.find((i) => i.kind === "runtime");
-      expect(runtimeIssue).toBeDefined();
-      expect(runtimeIssue?.message).toContain("Connection timeout");
-    });
-
-    it("should detect accounts that never connected", () => {
-      const snapshots: ChannelAccountSnapshot[] = [
-        {
-          accountId: "default",
-          configured: true,
-          enabled: true,
-          running: false,
-          lastStartAt: undefined,
-          lastInboundAt: undefined,
-          lastOutboundAt: undefined,
-        },
-      ];
-
-      const issues = collectTwitchStatusIssues(snapshots);
-
-      const neverConnectedIssue = issues.find((i) =>
-        i.message.includes("never connected successfully"),
-      );
-      expect(neverConnectedIssue).toBeDefined();
-    });
-
-    it("should detect long-running connections", () => {
-      const oldDate = Date.now() - 8 * 24 * 60 * 60 * 1000; // 8 days ago
-
-      const snapshots: ChannelAccountSnapshot[] = [
-        {
-          accountId: "default",
-          configured: true,
-          enabled: true,
-          running: true,
-          lastStartAt: oldDate,
-        },
-      ];
-
-      const issues = collectTwitchStatusIssues(snapshots);
-
-      const uptimeIssue = issues.find((i) => i.message.includes("running for"));
-      expect(uptimeIssue).toBeDefined();
-    });
-
-    it("should handle empty snapshots array", () => {
-      const issues = collectTwitchStatusIssues([]);
-
-      expect(issues).toEqual([]);
-    });
-
-    it("should skip non-Twitch accounts gracefully", () => {
-      const snapshots: ChannelAccountSnapshot[] = [
-        {
-          accountId: undefined,
-          configured: false,
-          enabled: true,
-          running: false,
-        },
-      ];
-
-      const issues = collectTwitchStatusIssues(snapshots);
-
-      // Should not crash, may return empty or minimal issues
-      expect(Array.isArray(issues)).toBe(true);
-    });
-  });
-});

package/extensions/twitch/src/status.ts

@@ -1,176 +0,0 @@
-/**
- * Twitch status issues collector.
- *
- * Detects and reports configuration issues for Twitch accounts.
- */
-
-import { getAccountConfig } from "./config.js";
-import type { ChannelAccountSnapshot, ChannelStatusIssue } from "./types.js";
-import { resolveTwitchToken } from "./token.js";
-import { isAccountConfigured } from "./utils/twitch.js";
-
-/**
- * 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}`));
- * }
- */
-export function collectTwitchStatusIssues(
-  accounts: ChannelAccountSnapshot[],
-  getCfg?: () => unknown,
-): ChannelStatusIssue[] {
-  const issues: ChannelStatusIssue[] = [];
-
-  for (const entry of accounts) {
-    const accountId = entry.accountId;
-
-    if (!accountId) continue;
-
-    let account: ReturnType<typeof getAccountConfig> | null = null;
-    let cfg: Parameters<typeof resolveTwitchToken>[0] | undefined;
-    if (getCfg) {
-      try {
-        cfg = getCfg() as {
-          channels?: { twitch?: { accounts?: Record<string, unknown> } };
-        };
-        account = getAccountConfig(cfg, accountId);
-      } catch {
-        // Ignore config access errors
-      }
-    }
-
-    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 as Parameters<typeof resolveTwitchToken>[0], { 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 uptime = Date.now() - entry.lastStartAt;
-      const daysSinceStart = uptime / (1000 * 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;
-}

package/extensions/twitch/src/token.test.ts

@@ -1,171 +0,0 @@
-/**
- * Tests for token.ts module
- *
- * Tests cover:
- * - Token resolution from config
- * - Token resolution from environment variable
- * - Fallback behavior when token not found
- * - Account ID normalization
- */
-
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { resolveTwitchToken, type TwitchTokenSource } from "./token.js";
-import type { ClawdbotConfig } from "clawdbot/plugin-sdk";
-
-describe("token", () => {
-  // Multi-account config for testing non-default accounts
-  const mockMultiAccountConfig = {
-    channels: {
-      twitch: {
-        accounts: {
-          default: {
-            username: "testbot",
-            accessToken: "oauth:config-token",
-          },
-          other: {
-            username: "otherbot",
-            accessToken: "oauth:other-token",
-          },
-        },
-      },
-    },
-  } as unknown as ClawdbotConfig;
-
-  // Simplified single-account config
-  const mockSimplifiedConfig = {
-    channels: {
-      twitch: {
-        username: "testbot",
-        accessToken: "oauth:config-token",
-      },
-    },
-  } as unknown as ClawdbotConfig;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-    delete process.env.CLAWDBOT_TWITCH_ACCESS_TOKEN;
-  });
-
-  describe("resolveTwitchToken", () => {
-    it("should resolve token from simplified config for default account", () => {
-      const result = resolveTwitchToken(mockSimplifiedConfig, { accountId: "default" });
-
-      expect(result.token).toBe("oauth:config-token");
-      expect(result.source).toBe("config");
-    });
-
-    it("should resolve token from config for non-default account (multi-account)", () => {
-      const result = resolveTwitchToken(mockMultiAccountConfig, { accountId: "other" });
-
-      expect(result.token).toBe("oauth:other-token");
-      expect(result.source).toBe("config");
-    });
-
-    it("should prioritize config token over env var (simplified config)", () => {
-      process.env.CLAWDBOT_TWITCH_ACCESS_TOKEN = "oauth:env-token";
-
-      const result = resolveTwitchToken(mockSimplifiedConfig, { accountId: "default" });
-
-      // Config token should be used even if env var exists
-      expect(result.token).toBe("oauth:config-token");
-      expect(result.source).toBe("config");
-    });
-
-    it("should use env var when config token is empty (simplified config)", () => {
-      process.env.CLAWDBOT_TWITCH_ACCESS_TOKEN = "oauth:env-token";
-
-      const configWithEmptyToken = {
-        channels: {
-          twitch: {
-            username: "testbot",
-            accessToken: "",
-          },
-        },
-      } as unknown as ClawdbotConfig;
-
-      const result = resolveTwitchToken(configWithEmptyToken, { accountId: "default" });
-
-      expect(result.token).toBe("oauth:env-token");
-      expect(result.source).toBe("env");
-    });
-
-    it("should return empty token when neither config nor env has token (simplified config)", () => {
-      const configWithoutToken = {
-        channels: {
-          twitch: {
-            username: "testbot",
-            accessToken: "",
-          },
-        },
-      } as unknown as ClawdbotConfig;
-
-      const result = resolveTwitchToken(configWithoutToken, { accountId: "default" });
-
-      expect(result.token).toBe("");
-      expect(result.source).toBe("none");
-    });
-
-    it("should not use env var for non-default accounts (multi-account)", () => {
-      process.env.CLAWDBOT_TWITCH_ACCESS_TOKEN = "oauth:env-token";
-
-      const configWithoutToken = {
-        channels: {
-          twitch: {
-            accounts: {
-              secondary: {
-                username: "secondary",
-                accessToken: "",
-              },
-            },
-          },
-        },
-      } as unknown as ClawdbotConfig;
-
-      const result = resolveTwitchToken(configWithoutToken, { accountId: "secondary" });
-
-      // Non-default accounts shouldn't use env var
-      expect(result.token).toBe("");
-      expect(result.source).toBe("none");
-    });
-
-    it("should handle missing account gracefully", () => {
-      const configWithoutAccount = {
-        channels: {
-          twitch: {
-            accounts: {},
-          },
-        },
-      } as unknown as ClawdbotConfig;
-
-      const result = resolveTwitchToken(configWithoutAccount, { accountId: "nonexistent" });
-
-      expect(result.token).toBe("");
-      expect(result.source).toBe("none");
-    });
-
-    it("should handle missing Twitch config section", () => {
-      const configWithoutSection = {
-        channels: {},
-      } as unknown as ClawdbotConfig;
-
-      const result = resolveTwitchToken(configWithoutSection, { accountId: "default" });
-
-      expect(result.token).toBe("");
-      expect(result.source).toBe("none");
-    });
-  });
-
-  describe("TwitchTokenSource type", () => {
-    it("should have correct values", () => {
-      const sources: TwitchTokenSource[] = ["env", "config", "none"];
-
-      expect(sources).toContain("env");
-      expect(sources).toContain("config");
-      expect(sources).toContain("none");
-    });
-  });
-});

package/extensions/twitch/src/token.ts

@@ -1,87 +0,0 @@
-/**
- * Twitch access token resolution with environment variable support.
- *
- * Supports reading Twitch OAuth access tokens from config or environment variable.
- * The CLAWDBOT_TWITCH_ACCESS_TOKEN env var is only used for the default account.
- *
- * Token resolution priority:
- * 1. Account access token from merged config (accounts.{id} or base-level for default)
- * 2. Environment variable: CLAWDBOT_TWITCH_ACCESS_TOKEN (default account only)
- */
-
-import type { ClawdbotConfig } from "../../../src/config/config.js";
-import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "../../../src/routing/session-key.js";
-
-export type TwitchTokenSource = "env" | "config" | "none";
-
-export type TwitchTokenResolution = {
-  token: string;
-  source: TwitchTokenSource;
-};
-
-/**
- * Normalize a Twitch OAuth token - ensure it has the oauth: prefix
- */
-function normalizeTwitchToken(raw?: string | null): string | undefined {
-  if (!raw) return undefined;
-  const trimmed = raw.trim();
-  if (!trimmed) return undefined;
-  // Twitch tokens should have oauth: prefix
-  return trimmed.startsWith("oauth:") ? trimmed : `oauth:${trimmed}`;
-}
-
-/**
- * Resolve Twitch access token from config or environment variable.
- *
- * Priority:
- * 1. Account access token (from merged config - base-level for default, or accounts.{accountId})
- * 2. Environment variable: CLAWDBOT_TWITCH_ACCESS_TOKEN (default account only)
- *
- * The getAccountConfig function handles merging base-level config with accounts.default,
- * so this logic works for both simplified and multi-account patterns.
- *
- * @param cfg - Clawdbot config
- * @param opts - Options including accountId and optional envToken override
- * @returns Token resolution with source
- */
-export function resolveTwitchToken(
-  cfg?: ClawdbotConfig,
-  opts: { accountId?: string | null; envToken?: string | null } = {},
-): TwitchTokenResolution {
-  const accountId = normalizeAccountId(opts.accountId);
-
-  // Get merged account config (handles both simplified and multi-account patterns)
-  const twitchCfg = cfg?.channels?.twitch;
-  const accountCfg =
-    accountId === DEFAULT_ACCOUNT_ID
-      ? (twitchCfg?.accounts?.[DEFAULT_ACCOUNT_ID] as Record<string, unknown> | undefined)
-      : (twitchCfg?.accounts?.[accountId as string] as Record<string, unknown> | undefined);
-
-  // For default account, also check base-level config
-  let token: string | undefined;
-  if (accountId === DEFAULT_ACCOUNT_ID) {
-    // Base-level config takes precedence
-    token = normalizeTwitchToken(
-      (typeof twitchCfg?.accessToken === "string" ? twitchCfg.accessToken : undefined) ||
-        (accountCfg?.accessToken as string | undefined),
-    );
-  } else {
-    // Non-default accounts only use accounts object
-    token = normalizeTwitchToken(accountCfg?.accessToken as string | undefined);
-  }
-
-  if (token) {
-    return { token, source: "config" };
-  }
-
-  // Environment variable (default account only)
-  const allowEnv = accountId === DEFAULT_ACCOUNT_ID;
-  const envToken = allowEnv
-    ? normalizeTwitchToken(opts.envToken ?? process.env.CLAWDBOT_TWITCH_ACCESS_TOKEN)
-    : undefined;
-  if (envToken) {
-    return { token: envToken, source: "env" };
-  }
-
-  return { token: "", source: "none" };
-}