Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

6.7 KB
Raw Blame
type SlackRetryOptions = {
  retries?: number | undefined;
  rejectRateLimitedCalls?: boolean | undefined;
};

import type { iMessageAdapter } from "@photon-ai/chat-adapter-imessage";
import { type Adapter, type ChatInstance } from "chat";
import { vi } from "vite-plus/test";

const photon = vi.hoisted(() => ({
  adapter: null as iMessageAdapter | null,
  chat: null as ChatInstance | null,
  failedSubscription: null as string | null,
  gatewayError: null as Error | null,
  gatewayStatus: 200,
  subscriptionAttempts: [] as string[],
}));

const externalAdapters = vi.hoisted(() => ({
  slackAdapter: null as Adapter | null,
  slackChat: null as ChatInstance | null,
  slackDisconnects: 0,
  slackIdentityAvailable: true,
  slackInitializationFails: false,
  slackSubscriptions: [] as string[],
  slackRestoredBeforeInitialize: false,
  slackResponses: [] as Array<
    { status: number; data: unknown; headers?: Record<string, string> } | Error
  >,
  slackPostRequests: 0,
  slackRetryOptions: {} as SlackRetryOptions,
  discordAdapter: null as Adapter | null,
  discordChat: null as ChatInstance | null,
  discordGatewayStarts: 0,
  discordIdentityFails: false,
  discordDisconnects: 0,
  discordSubscriptions: [] as string[],
  reactions: [] as string[],
}));

vi.mock("@photon-ai/chat-adapter-imessage", async (importOriginal) => {
  const actual = await importOriginal<typeof import("@photon-ai/chat-adapter-imessage")>();

  return {
    ...actual,
    createiMessageAdapter: (
      options: Parameters<typeof actual.createiMessageAdapter>[0],
    ): iMessageAdapter => {
      const adapter = actual.createiMessageAdapter(options) as iMessageAdapter & Adapter;
      adapter.initialize = async (chat) => {
        photon.adapter = adapter;
        photon.chat = chat;
      };

      adapter.startGatewayListener = async ({ waitUntil }, _durationMs, signal) => {
        if (photon.gatewayError) throw photon.gatewayError;
        waitUntil?.(
          new Promise<void>((resolve) => {
            if (signal?.aborted) return resolve();
            signal?.addEventListener("abort", () => resolve(), { once: true });
          }),
        );

        return new Response(null, { status: photon.gatewayStatus });
      };

      adapter.onThreadSubscribe = async (threadId) => {
        photon.subscriptionAttempts.push(threadId);

        if (threadId === photon.failedSubscription) throw new Error("invalid group GUID");
      };

      adapter.disconnect = async () => undefined;

      return adapter;
    },
  };
});

vi.mock("@chat-adapter/slack", async (importOriginal) => {
  const actual = await importOriginal<typeof import("@chat-adapter/slack")>();

  return {
    ...actual,
    createSlackAdapter: (options: Parameters<typeof actual.createSlackAdapter>[0] = {}) => {
      externalAdapters.slackRetryOptions = {
        retries: options.webClientOptions?.retryConfig?.retries,
        rejectRateLimitedCalls: options.webClientOptions?.rejectRateLimitedCalls,
      };

      const adapter = actual.createSlackAdapter({
        ...options,
        webClientOptions: {
          ...options.webClientOptions,
          adapter: async (config) => {
            if (config.url !== "https://slack.com/api/chat.postMessage") {
              throw new Error("Unexpected Slack API request");
            }

            externalAdapters.slackPostRequests += 1;
            const response = externalAdapters.slackResponses.shift();

            if (response instanceof Error) throw response;

            if (!response) throw new Error("Missing Slack API response");

            return {
              ...response,
              headers: response.headers ?? {},
              statusText: "",
              config,
              request: { path: "/api/chat.postMessage" },
            };
          },
        },
      }) as ReturnType<typeof actual.createSlackAdapter> & Adapter;

      adapter.initialize = async (chat) => {
        if (externalAdapters.slackIdentityAvailable) {
          Object.assign(adapter, { _botUserId: "U-AKERU" });
        }

        externalAdapters.slackAdapter = adapter;
        externalAdapters.slackChat = chat;
        externalAdapters.slackRestoredBeforeInitialize = await chat
          .getState()
          .isSubscribed("slack:C1:1");

        if (externalAdapters.slackInitializationFails) throw new Error("Socket startup failed");
      };

      adapter.addReaction = async (threadId, messageId, emoji) => {
        externalAdapters.reactions.push(`add:${threadId}:${messageId}:${String(emoji)}`);
      };

      adapter.removeReaction = async (threadId, messageId, emoji) => {
        externalAdapters.reactions.push(`remove:${threadId}:${messageId}:${String(emoji)}`);
      };

      adapter.onThreadSubscribe = async (threadId) => {
        externalAdapters.slackSubscriptions.push(threadId);
      };

      adapter.disconnect = async () => {
        externalAdapters.slackDisconnects += 1;
      };

      return adapter;
    },
  };
});

vi.mock("@chat-adapter/discord", async (importOriginal) => {
  const actual = await importOriginal<typeof import("@chat-adapter/discord")>();

  return {
    ...actual,
    createDiscordAdapter: (options: Parameters<typeof actual.createDiscordAdapter>[0]) => {
      const adapter = actual.createDiscordAdapter(options) as ReturnType<
        typeof actual.createDiscordAdapter
      > &
        Adapter;

      adapter.initialize = async (chat) => {
        externalAdapters.discordAdapter = adapter;
        externalAdapters.discordChat = chat;
      };

      adapter.getUser = async (userId) => {
        if (externalAdapters.discordIdentityFails) throw new Error("Discord identity failed");

        return { userId, userName: "akeru-discord", fullName: "Akeru Discord", isBot: true };
      };

      adapter.disconnect = async () => {
        externalAdapters.discordDisconnects += 1;
      };

      adapter.addReaction = async (threadId, messageId, emoji) => {
        externalAdapters.reactions.push(`add:${threadId}:${messageId}:${String(emoji)}`);
      };

      adapter.removeReaction = async (threadId, messageId, emoji) => {
        externalAdapters.reactions.push(`remove:${threadId}:${messageId}:${String(emoji)}`);
      };

      adapter.onThreadSubscribe = async (threadId) => {
        externalAdapters.discordSubscriptions.push(threadId);
      };

      adapter.startGatewayListener = async ({ waitUntil }, _durationMs, signal) => {
        externalAdapters.discordGatewayStarts += 1;
        waitUntil?.(
          new Promise<void>((resolve) => {
            if (signal?.aborted) return resolve();
            signal?.addEventListener("abort", () => resolve(), { once: true });
          }),
        );

        return new Response(null, { status: 200 });
      };

      return adapter;
    },
  };
});

export { photon, externalAdapters };