@gguf/pigbot 0.0.1 → 0.0.3

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

@@ -0,0 +1,270 @@
+/**
+ * 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

@@ -0,0 +1,176 @@
+/**
+ * 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

@@ -0,0 +1,171 @@
+/**
+ * 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 { MoltbotConfig } 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 MoltbotConfig;
+
+  // Simplified single-account config
+  const mockSimplifiedConfig = {
+    channels: {
+      twitch: {
+        username: "testbot",
+        accessToken: "oauth:config-token",
+      },
+    },
+  } as unknown as MoltbotConfig;
+
+  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 MoltbotConfig;
+
+      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 MoltbotConfig;
+
+      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 MoltbotConfig;
+
+      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 MoltbotConfig;
+
+      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 MoltbotConfig;
+
+      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

@@ -0,0 +1,87 @@
+/**
+ * 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 { MoltbotConfig } 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 - Moltbot config
+ * @param opts - Options including accountId and optional envToken override
+ * @returns Token resolution with source
+ */
+export function resolveTwitchToken(
+  cfg?: MoltbotConfig,
+  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" };
+}