loudmouth-ai 0.1.0 → 0.2.0

package/extensions/twitch/src/monitor.ts

@@ -1,257 +0,0 @@
-/**
- * Twitch message monitor - processes incoming messages and routes to agents.
- *
- * This monitor connects to the Twitch client manager, processes incoming messages,
- * resolves agent routes, and handles replies.
- */
-
-import type { ReplyPayload, ClawdbotConfig } from "clawdbot/plugin-sdk";
-import type { TwitchAccountConfig, TwitchChatMessage } from "./types.js";
-import { checkTwitchAccessControl } from "./access-control.js";
-import { getTwitchRuntime } from "./runtime.js";
-import { getOrCreateClientManager } from "./client-manager-registry.js";
-import { stripMarkdownForTwitch } from "./utils/markdown.js";
-
-export type TwitchRuntimeEnv = {
-  log?: (message: string) => void;
-  error?: (message: string) => void;
-};
-
-export type TwitchMonitorOptions = {
-  account: TwitchAccountConfig;
-  accountId: string;
-  config: unknown; // ClawdbotConfig
-  runtime: TwitchRuntimeEnv;
-  abortSignal: AbortSignal;
-  statusSink?: (patch: { lastInboundAt?: number; lastOutboundAt?: number }) => void;
-};
-
-export type TwitchMonitorResult = {
-  stop: () => void;
-};
-
-type TwitchCoreRuntime = ReturnType<typeof getTwitchRuntime>;
-
-/**
- * Process an incoming Twitch message and dispatch to agent.
- */
-async function processTwitchMessage(params: {
-  message: TwitchChatMessage;
-  account: TwitchAccountConfig;
-  accountId: string;
-  config: unknown;
-  runtime: TwitchRuntimeEnv;
-  core: TwitchCoreRuntime;
-  statusSink?: (patch: { lastInboundAt?: number; lastOutboundAt?: number }) => void;
-}): Promise<void> {
-  const { message, account, accountId, config, runtime, core, statusSink } = params;
-  const cfg = config as ClawdbotConfig;
-
-  const route = core.channel.routing.resolveAgentRoute({
-    cfg,
-    channel: "twitch",
-    accountId,
-    peer: {
-      kind: "group", // Twitch chat is always group-like
-      id: message.channel,
-    },
-  });
-
-  const rawBody = message.message;
-  const body = core.channel.reply.formatAgentEnvelope({
-    channel: "Twitch",
-    from: message.displayName ?? message.username,
-    timestamp: message.timestamp?.getTime(),
-    envelope: core.channel.reply.resolveEnvelopeFormatOptions(cfg),
-    body: rawBody,
-  });
-
-  const ctxPayload = core.channel.reply.finalizeInboundContext({
-    Body: body,
-    RawBody: rawBody,
-    CommandBody: rawBody,
-    From: `twitch:user:${message.userId}`,
-    To: `twitch:channel:${message.channel}`,
-    SessionKey: route.sessionKey,
-    AccountId: route.accountId,
-    ChatType: "group",
-    ConversationLabel: message.channel,
-    SenderName: message.displayName ?? message.username,
-    SenderId: message.userId,
-    SenderUsername: message.username,
-    Provider: "twitch",
-    Surface: "twitch",
-    MessageSid: message.id,
-    OriginatingChannel: "twitch",
-    OriginatingTo: `twitch:channel:${message.channel}`,
-  });
-
-  const storePath = core.channel.session.resolveStorePath(cfg.session?.store, {
-    agentId: route.agentId,
-  });
-  await core.channel.session.recordInboundSession({
-    storePath,
-    sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
-    ctx: ctxPayload,
-    onRecordError: (err) => {
-      runtime.error?.(`Failed updating session meta: ${String(err)}`);
-    },
-  });
-
-  const tableMode = core.channel.text.resolveMarkdownTableMode({
-    cfg,
-    channel: "twitch",
-    accountId,
-  });
-
-  await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
-    ctx: ctxPayload,
-    cfg,
-    dispatcherOptions: {
-      deliver: async (payload) => {
-        await deliverTwitchReply({
-          payload,
-          channel: message.channel,
-          account,
-          accountId,
-          config,
-          tableMode,
-          runtime,
-          statusSink,
-        });
-      },
-    },
-  });
-}
-
-/**
- * Deliver a reply to Twitch chat.
- */
-async function deliverTwitchReply(params: {
-  payload: ReplyPayload;
-  channel: string;
-  account: TwitchAccountConfig;
-  accountId: string;
-  config: unknown;
-  tableMode: "off" | "plain" | "markdown" | "bullets" | "code";
-  runtime: TwitchRuntimeEnv;
-  statusSink?: (patch: { lastInboundAt?: number; lastOutboundAt?: number }) => void;
-}): Promise<void> {
-  const { payload, channel, account, accountId, config, tableMode, runtime, statusSink } = params;
-
-  try {
-    const clientManager = getOrCreateClientManager(accountId, {
-      info: (msg) => runtime.log?.(msg),
-      warn: (msg) => runtime.log?.(msg),
-      error: (msg) => runtime.error?.(msg),
-      debug: (msg) => runtime.log?.(msg),
-    });
-
-    const client = await clientManager.getClient(
-      account,
-      config as Parameters<typeof clientManager.getClient>[1],
-      accountId,
-    );
-    if (!client) {
-      runtime.error?.(`No client available for sending reply`);
-      return;
-    }
-
-    // Send the reply
-    if (!payload.text) {
-      runtime.error?.(`No text to send in reply payload`);
-      return;
-    }
-
-    const textToSend = stripMarkdownForTwitch(payload.text);
-
-    await client.say(channel, textToSend);
-    statusSink?.({ lastOutboundAt: Date.now() });
-  } catch (err) {
-    runtime.error?.(`Failed to send reply: ${String(err)}`);
-  }
-}
-
-/**
- * Main monitor provider for Twitch.
- *
- * Sets up message handlers and processes incoming messages.
- */
-export async function monitorTwitchProvider(
-  options: TwitchMonitorOptions,
-): Promise<TwitchMonitorResult> {
-  const { account, accountId, config, runtime, abortSignal, statusSink } = options;
-
-  const core = getTwitchRuntime();
-  let stopped = false;
-
-  const coreLogger = core.logging.getChildLogger({ module: "twitch" });
-  const logVerboseMessage = (message: string) => {
-    if (!core.logging.shouldLogVerbose()) return;
-    coreLogger.debug?.(message);
-  };
-  const logger = {
-    info: (msg: string) => coreLogger.info(msg),
-    warn: (msg: string) => coreLogger.warn(msg),
-    error: (msg: string) => coreLogger.error(msg),
-    debug: logVerboseMessage,
-  };
-
-  const clientManager = getOrCreateClientManager(accountId, logger);
-
-  try {
-    await clientManager.getClient(
-      account,
-      config as Parameters<typeof clientManager.getClient>[1],
-      accountId,
-    );
-  } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : String(error);
-    runtime.error?.(`Failed to connect: ${errorMsg}`);
-    throw error;
-  }
-
-  const unregisterHandler = clientManager.onMessage(account, (message) => {
-    if (stopped) return;
-
-    // Access control check
-    const botUsername = account.username.toLowerCase();
-    if (message.username.toLowerCase() === botUsername) {
-      return; // Ignore own messages
-    }
-
-    const access = checkTwitchAccessControl({
-      message,
-      account,
-      botUsername,
-    });
-
-    if (!access.allowed) {
-      return;
-    }
-
-    statusSink?.({ lastInboundAt: Date.now() });
-
-    // Fire-and-forget: process message without blocking
-    void processTwitchMessage({
-      message,
-      account,
-      accountId,
-      config,
-      runtime,
-      core,
-      statusSink,
-    }).catch((err) => {
-      runtime.error?.(`Message processing failed: ${String(err)}`);
-    });
-  });
-
-  const stop = () => {
-    stopped = true;
-    unregisterHandler();
-  };
-
-  abortSignal.addEventListener("abort", stop, { once: true });
-
-  return { stop };
-}

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

@@ -1,311 +0,0 @@
-/**
- * Tests for onboarding.ts helpers
- *
- * Tests cover:
- * - promptToken helper
- * - promptUsername helper
- * - promptClientId helper
- * - promptChannelName helper
- * - promptRefreshTokenSetup helper
- * - configureWithEnvToken helper
- * - setTwitchAccount config updates
- */
-
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import type { WizardPrompter } from "clawdbot/plugin-sdk";
-import type { TwitchAccountConfig } from "./types.js";
-
-// Mock the helpers we're testing
-const mockPromptText = vi.fn();
-const mockPromptConfirm = vi.fn();
-const mockPrompter: WizardPrompter = {
-  text: mockPromptText,
-  confirm: mockPromptConfirm,
-} as unknown as WizardPrompter;
-
-const mockAccount: TwitchAccountConfig = {
-  username: "testbot",
-  accessToken: "oauth:test123",
-  clientId: "test-client-id",
-  channel: "#testchannel",
-};
-
-describe("onboarding helpers", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    // Don't restoreAllMocks as it breaks module-level mocks
-  });
-
-  describe("promptToken", () => {
-    it("should return existing token when user confirms to keep it", async () => {
-      const { promptToken } = await import("./onboarding.js");
-
-      mockPromptConfirm.mockResolvedValue(true);
-
-      const result = await promptToken(mockPrompter, mockAccount, undefined);
-
-      expect(result).toBe("oauth:test123");
-      expect(mockPromptConfirm).toHaveBeenCalledWith({
-        message: "Access token already configured. Keep it?",
-        initialValue: true,
-      });
-      expect(mockPromptText).not.toHaveBeenCalled();
-    });
-
-    it("should prompt for new token when user doesn't keep existing", async () => {
-      const { promptToken } = await import("./onboarding.js");
-
-      mockPromptConfirm.mockResolvedValue(false);
-      mockPromptText.mockResolvedValue("oauth:newtoken123");
-
-      const result = await promptToken(mockPrompter, mockAccount, undefined);
-
-      expect(result).toBe("oauth:newtoken123");
-      expect(mockPromptText).toHaveBeenCalledWith({
-        message: "Twitch OAuth token (oauth:...)",
-        initialValue: "",
-        validate: expect.any(Function),
-      });
-    });
-
-    it("should use env token as initial value when provided", async () => {
-      const { promptToken } = await import("./onboarding.js");
-
-      mockPromptConfirm.mockResolvedValue(false);
-      mockPromptText.mockResolvedValue("oauth:fromenv");
-
-      await promptToken(mockPrompter, null, "oauth:fromenv");
-
-      expect(mockPromptText).toHaveBeenCalledWith(
-        expect.objectContaining({
-          initialValue: "oauth:fromenv",
-        }),
-      );
-    });
-
-    it("should validate token format", async () => {
-      const { promptToken } = await import("./onboarding.js");
-
-      // Set up mocks - user doesn't want to keep existing token
-      mockPromptConfirm.mockResolvedValueOnce(false);
-
-      // Track how many times promptText is called
-      let promptTextCallCount = 0;
-      let capturedValidate: ((value: string) => string | undefined) | undefined;
-
-      mockPromptText.mockImplementationOnce((_args) => {
-        promptTextCallCount++;
-        // Capture the validate function from the first argument
-        if (_args?.validate) {
-          capturedValidate = _args.validate;
-        }
-        return Promise.resolve("oauth:test123");
-      });
-
-      // Call promptToken
-      const result = await promptToken(mockPrompter, mockAccount, undefined);
-
-      // Verify promptText was called
-      expect(promptTextCallCount).toBe(1);
-      expect(result).toBe("oauth:test123");
-
-      // Test the validate function
-      expect(capturedValidate).toBeDefined();
-      expect(capturedValidate!("")).toBe("Required");
-      expect(capturedValidate!("notoauth")).toBe("Token should start with 'oauth:'");
-    });
-
-    it("should return early when no existing token and no env token", async () => {
-      const { promptToken } = await import("./onboarding.js");
-
-      mockPromptText.mockResolvedValue("oauth:newtoken");
-
-      const result = await promptToken(mockPrompter, null, undefined);
-
-      expect(result).toBe("oauth:newtoken");
-      expect(mockPromptConfirm).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("promptUsername", () => {
-    it("should prompt for username with validation", async () => {
-      const { promptUsername } = await import("./onboarding.js");
-
-      mockPromptText.mockResolvedValue("mybot");
-
-      const result = await promptUsername(mockPrompter, null);
-
-      expect(result).toBe("mybot");
-      expect(mockPromptText).toHaveBeenCalledWith({
-        message: "Twitch bot username",
-        initialValue: "",
-        validate: expect.any(Function),
-      });
-    });
-
-    it("should use existing username as initial value", async () => {
-      const { promptUsername } = await import("./onboarding.js");
-
-      mockPromptText.mockResolvedValue("testbot");
-
-      await promptUsername(mockPrompter, mockAccount);
-
-      expect(mockPromptText).toHaveBeenCalledWith(
-        expect.objectContaining({
-          initialValue: "testbot",
-        }),
-      );
-    });
-  });
-
-  describe("promptClientId", () => {
-    it("should prompt for client ID with validation", async () => {
-      const { promptClientId } = await import("./onboarding.js");
-
-      mockPromptText.mockResolvedValue("abc123xyz");
-
-      const result = await promptClientId(mockPrompter, null);
-
-      expect(result).toBe("abc123xyz");
-      expect(mockPromptText).toHaveBeenCalledWith({
-        message: "Twitch Client ID",
-        initialValue: "",
-        validate: expect.any(Function),
-      });
-    });
-  });
-
-  describe("promptChannelName", () => {
-    it("should return channel name when provided", async () => {
-      const { promptChannelName } = await import("./onboarding.js");
-
-      mockPromptText.mockResolvedValue("#mychannel");
-
-      const result = await promptChannelName(mockPrompter, null);
-
-      expect(result).toBe("#mychannel");
-    });
-
-    it("should require a non-empty channel name", async () => {
-      const { promptChannelName } = await import("./onboarding.js");
-
-      mockPromptText.mockResolvedValue("");
-
-      await promptChannelName(mockPrompter, null);
-
-      const { validate } = mockPromptText.mock.calls[0]?.[0] ?? {};
-      expect(validate?.("")).toBe("Required");
-      expect(validate?.("   ")).toBe("Required");
-      expect(validate?.("#chan")).toBeUndefined();
-    });
-  });
-
-  describe("promptRefreshTokenSetup", () => {
-    it("should return empty object when user declines", async () => {
-      const { promptRefreshTokenSetup } = await import("./onboarding.js");
-
-      mockPromptConfirm.mockResolvedValue(false);
-
-      const result = await promptRefreshTokenSetup(mockPrompter, mockAccount);
-
-      expect(result).toEqual({});
-      expect(mockPromptConfirm).toHaveBeenCalledWith({
-        message: "Enable automatic token refresh (requires client secret and refresh token)?",
-        initialValue: false,
-      });
-    });
-
-    it("should prompt for credentials when user accepts", async () => {
-      const { promptRefreshTokenSetup } = await import("./onboarding.js");
-
-      mockPromptConfirm
-        .mockResolvedValueOnce(true) // First call: useRefresh
-        .mockResolvedValueOnce("secret123") // clientSecret
-        .mockResolvedValueOnce("refresh123"); // refreshToken
-
-      mockPromptText.mockResolvedValueOnce("secret123").mockResolvedValueOnce("refresh123");
-
-      const result = await promptRefreshTokenSetup(mockPrompter, null);
-
-      expect(result).toEqual({
-        clientSecret: "secret123",
-        refreshToken: "refresh123",
-      });
-    });
-
-    it("should use existing values as initial prompts", async () => {
-      const { promptRefreshTokenSetup } = await import("./onboarding.js");
-
-      const accountWithRefresh = {
-        ...mockAccount,
-        clientSecret: "existing-secret",
-        refreshToken: "existing-refresh",
-      };
-
-      mockPromptConfirm.mockResolvedValue(true);
-      mockPromptText
-        .mockResolvedValueOnce("existing-secret")
-        .mockResolvedValueOnce("existing-refresh");
-
-      await promptRefreshTokenSetup(mockPrompter, accountWithRefresh);
-
-      expect(mockPromptConfirm).toHaveBeenCalledWith(
-        expect.objectContaining({
-          initialValue: true, // Both clientSecret and refreshToken exist
-        }),
-      );
-    });
-  });
-
-  describe("configureWithEnvToken", () => {
-    it("should return null when user declines env token", async () => {
-      const { configureWithEnvToken } = await import("./onboarding.js");
-
-      // Reset and set up mock - user declines env token
-      mockPromptConfirm.mockReset().mockResolvedValue(false as never);
-
-      const result = await configureWithEnvToken(
-        {} as Parameters<typeof configureWithEnvToken>[0],
-        mockPrompter,
-        null,
-        "oauth:fromenv",
-        false,
-        {} as Parameters<typeof configureWithEnvToken>[5],
-      );
-
-      // Since user declined, should return null without prompting for username/clientId
-      expect(result).toBeNull();
-      expect(mockPromptText).not.toHaveBeenCalled();
-    });
-
-    it("should prompt for username and clientId when using env token", async () => {
-      const { configureWithEnvToken } = await import("./onboarding.js");
-
-      // Reset and set up mocks - user accepts env token
-      mockPromptConfirm.mockReset().mockResolvedValue(true as never);
-
-      // Set up mocks for username and clientId prompts
-      mockPromptText
-        .mockReset()
-        .mockResolvedValueOnce("testbot" as never)
-        .mockResolvedValueOnce("test-client-id" as never);
-
-      const result = await configureWithEnvToken(
-        {} as Parameters<typeof configureWithEnvToken>[0],
-        mockPrompter,
-        null,
-        "oauth:fromenv",
-        false,
-        {} as Parameters<typeof configureWithEnvToken>[5],
-      );
-
-      // Should return config with username and clientId
-      expect(result).not.toBeNull();
-      expect(result?.cfg.channels?.twitch?.accounts?.default?.username).toBe("testbot");
-      expect(result?.cfg.channels?.twitch?.accounts?.default?.clientId).toBe("test-client-id");
-    });
-  });
-});