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.

17.4 KB
Raw Blame
import { it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as Option from "effect/Option";
import { describe, expect, vi } from "vite-plus/test";

import type { ServerSecretStore } from "../auth/ServerSecretStore.ts";
import { toClaudeMcpServers } from "../provider/McpServerConfig.ts";
import { make } from "./ComposioService.ts";

function makeSecretStore(initial: Readonly<Record<string, string>> = {}) {
  const values = new Map(
    Object.entries(initial).map(([name, value]) => [name, new TextEncoder().encode(value)]),
  );

  const store = {
    get: (name: string) => Effect.sync(() => Option.fromNullishOr(values.get(name))),
    set: (name: string, value: Uint8Array) =>
      Effect.sync(() => void values.set(name, new Uint8Array(value))),
    create: (name: string, value: Uint8Array) =>
      Effect.sync(() => void values.set(name, new Uint8Array(value))),
    getOrCreateRandom: (name: string, bytes: number) =>
      Effect.sync(() => {
        const existing = values.get(name);

        if (existing) return existing;
        const value = new Uint8Array(bytes).fill(7);
        values.set(name, value);

        return value;
      }),
    remove: (name: string) => Effect.sync(() => void values.delete(name)),
  } satisfies ServerSecretStore["Service"];

  return { store, values };
}

function fakeClient(input?: {
  readonly accounts?: ReadonlyArray<{
    readonly id: string;
    readonly toolkit: { readonly slug: string };
    readonly status: "ACTIVE" | "FAILED";
    readonly alias?: string | null;
  }>;
  readonly authorize?: () => Promise<{
    readonly id: string;
    readonly redirectUrl?: string;
  }>;
  readonly deleteSession?: () => Promise<void>;
  readonly sessionCreationGate?: Promise<void>;
  readonly sessionCreationGates?: readonly Promise<void>[];
}) {
  const sessionDeletes: Array<ReturnType<typeof vi.fn<() => Promise<void>>>> = [];

  const createSession = vi.fn(async () => {
    await (input?.sessionCreationGates?.[createSession.mock.calls.length - 1] ??
      input?.sessionCreationGate);
    const deleteSession = vi.fn(input?.deleteSession ?? (async () => undefined));
    sessionDeletes.push(deleteSession);

    return {
      mcp: {
        url: "https://app.composio.dev/tool_router/v3/session/mcp",
        headers: { "x-api-key": "project-key" },
      },
      authorize: vi.fn(
        input?.authorize ??
          (async () => ({
            id: "connection-new",
            redirectUrl: "https://connect.composio.dev/link",
          })),
      ),
      delete: deleteSession,
    };
  });

  const client = {
    toolkits: { get: vi.fn(async () => []) },
    connectedAccounts: {
      list: vi.fn(async () => ({ items: input?.accounts ?? [], totalPages: 1 })),
      delete: vi.fn(async () => ({})),
    },
    sessions: { create: createSession },
  };

  return { client, createSession, sessionDeletes };
}

describe("ComposioService", () => {
  it.effect("validates a key before storing it", () =>
    Effect.gen(function* () {
      const { store, values } = makeSecretStore();
      const { client } = fakeClient();
      const service = make(store, () => client);

      expect(yield* service.configure(" project-key ")).toEqual({
        configured: true,
        connections: [],
      });
      expect(new TextDecoder().decode(values.get("composio-api-key"))).toBe("project-key");
    }),
  );

  it.effect("does not store an invalid key", () =>
    Effect.gen(function* () {
      const { store, values } = makeSecretStore();
      const { client } = fakeClient();
      vi.mocked(client.toolkits.get).mockRejectedValueOnce(
        Object.assign(new Error(), { status: 401 }),
      );
      const service = make(store, () => client);

      const error = yield* Effect.flip(service.configure("bad-key"));
      expect(error).toMatchObject({ message: "The Composio API key is invalid." });
      expect(values.has("composio-api-key")).toBe(false);
    }),
  );

  it.effect("deletes its hosted session after starting authorization", () =>
    Effect.gen(function* () {
      const { store } = makeSecretStore({ "composio-api-key": "project-key" });
      const { client, sessionDeletes } = fakeClient();
      const service = make(store, () => client);

      expect(yield* service.authorize({ toolkitSlug: "gmail" })).toEqual({
        connectionId: "connection-new",
        redirectUrl: "https://connect.composio.dev/link",
      });
      expect(sessionDeletes[0]).toHaveBeenCalledTimes(1);
    }),
  );

  it.effect("deletes its hosted session when authorization fails", () =>
    Effect.gen(function* () {
      const { store } = makeSecretStore({ "composio-api-key": "project-key" });

      const { client, sessionDeletes } = fakeClient({
        authorize: () => Promise.reject(new Error("authorization failed")),
      });

      const service = make(store, () => client);

      expect(yield* Effect.flip(service.authorize({ toolkitSlug: "gmail" }))).toMatchObject({
        operation: "start account authorization",
        message: "Composio could not start account authorization.",
      });
      expect(sessionDeletes[0]).toHaveBeenCalledTimes(1);
    }),
  );

  it.effect("deletes its hosted session when the authorization URL is missing", () =>
    Effect.gen(function* () {
      const { store } = makeSecretStore({ "composio-api-key": "project-key" });

      const { client, sessionDeletes } = fakeClient({
        authorize: async () => ({ id: "connection-new" }),
      });

      const service = make(store, () => client);

      expect(yield* Effect.flip(service.authorize({ toolkitSlug: "gmail" }))).toMatchObject({
        operation: "start account authorization",
        message: "Composio could not start account authorization.",
      });
      expect(sessionDeletes[0]).toHaveBeenCalledTimes(1);
    }),
  );

  it.effect("retries failed authorization-session cleanup before authorizing again", () =>
    Effect.gen(function* () {
      let cleanupAttempt = 0;
      const { store } = makeSecretStore({ "composio-api-key": "project-key" });

      const { client, createSession, sessionDeletes } = fakeClient({
        deleteSession: async () => {
          cleanupAttempt += 1;

          if (cleanupAttempt === 1) throw new Error("cleanup response was lost");

          if (cleanupAttempt === 2) {
            throw Object.assign(new Error("session not found"), { status: 404 });
          }
        },
      });

      const service = make(store, () => client);

      expect(yield* Effect.flip(service.authorize({ toolkitSlug: "gmail" }))).toMatchObject({
        operation: "start account authorization",
        message: "Composio could not start account authorization.",
      });
      expect(sessionDeletes[0]).toHaveBeenCalledTimes(1);

      expect(yield* service.authorize({ toolkitSlug: "gmail" })).toEqual({
        connectionId: "connection-new",
        redirectUrl: "https://connect.composio.dev/link",
      });
      expect(createSession).toHaveBeenCalledTimes(2);
      expect(sessionDeletes[0]).toHaveBeenCalledTimes(2);
      expect(sessionDeletes[1]).toHaveBeenCalledTimes(1);
    }),
  );

  it.effect("keeps multiple accounts and MCP headers in transient runtime state", () =>
    Effect.gen(function* () {
      const { store } = makeSecretStore({ "composio-api-key": "project-key" });

      const { client, createSession } = fakeClient({
        accounts: [
          { id: "gmail-work", toolkit: { slug: "gmail" }, status: "ACTIVE", alias: "Work" },
          { id: "gmail-home", toolkit: { slug: "gmail" }, status: "ACTIVE", alias: "Home" },
          { id: "slack-failed", toolkit: { slug: "slack" }, status: "FAILED" },
        ],
      });

      const service = make(store, () => client);

      const status = yield* service.getStatus;
      expect(status.connections).toHaveLength(3);

      const first = yield* service.resolveRuntimeMcpServer("thread-1");
      const cached = yield* service.resolveRuntimeMcpServer("thread-1");
      const secondThread = yield* service.resolveRuntimeMcpServer("thread-2");

      expect(first).toBe(cached);
      expect(secondThread).toBeDefined();
      expect(createSession).toHaveBeenCalledTimes(2);
      expect(createSession).toHaveBeenCalledWith(
        expect.any(String),
        expect.objectContaining({
          connectedAccounts: { gmail: ["gmail-work", "gmail-home"] },
          multiAccount: expect.objectContaining({ requireExplicitSelection: true }),
        }),
      );
      expect(toClaudeMcpServers([first!])).toEqual({
        "composio-session": {
          type: "http",
          url: "https://app.composio.dev/tool_router/v3/session/mcp",
          headers: { "x-api-key": "project-key" },
        },
      });
      expect(first).toEqual({
        id: "composio-session",
        name: "Composio",
        transport: "url",
        url: "https://app.composio.dev/tool_router/v3/session/mcp",
        enabled: true,
        createdAt: "1970-01-01T00:00:00.000Z",
        updatedAt: "1970-01-01T00:00:00.000Z",
      });
    }),
  );

  it.effect("reuses a hosted runtime when account and toolkit order changes", () =>
    Effect.gen(function* () {
      const { store } = makeSecretStore({ "composio-api-key": "project-key" });

      const { client, createSession, sessionDeletes } = fakeClient({
        accounts: [
          { id: "gmail-work", toolkit: { slug: "gmail" }, status: "ACTIVE" },
          { id: "slack-work", toolkit: { slug: "slack" }, status: "ACTIVE" },
          { id: "gmail-home", toolkit: { slug: "gmail" }, status: "ACTIVE" },
        ],
      });

      const service = make(store, () => client);

      const first = yield* service.resolveRuntimeMcpServer("thread-1");
      vi.mocked(client.connectedAccounts.list).mockResolvedValue({
        items: [
          { id: "gmail-home", toolkit: { slug: "gmail" }, status: "ACTIVE" },
          { id: "gmail-work", toolkit: { slug: "gmail" }, status: "ACTIVE" },
          { id: "slack-work", toolkit: { slug: "slack" }, status: "ACTIVE" },
        ],
        totalPages: 1,
      } as never);
      const reordered = yield* service.resolveRuntimeMcpServer("thread-1");

      expect(reordered).toBe(first);
      expect(createSession).toHaveBeenCalledTimes(1);
      expect(sessionDeletes[0]).not.toHaveBeenCalled();
    }),
  );

  it.effect("replaces a hosted runtime when active account status changes", () =>
    Effect.gen(function* () {
      const { store } = makeSecretStore({ "composio-api-key": "project-key" });

      const { client, createSession, sessionDeletes } = fakeClient({
        accounts: [
          { id: "gmail-work", toolkit: { slug: "gmail" }, status: "ACTIVE" },
          { id: "gmail-home", toolkit: { slug: "gmail" }, status: "ACTIVE" },
        ],
      });

      const service = make(store, () => client);

      yield* service.resolveRuntimeMcpServer("thread-1");
      vi.mocked(client.connectedAccounts.list).mockResolvedValue({
        items: [
          { id: "gmail-work", toolkit: { slug: "gmail" }, status: "ACTIVE" },
          { id: "gmail-home", toolkit: { slug: "gmail" }, status: "FAILED" },
        ],
        totalPages: 1,
      } as never);
      yield* service.resolveRuntimeMcpServer("thread-1");

      expect(createSession).toHaveBeenCalledTimes(2);
      expect(sessionDeletes[0]).toHaveBeenCalledTimes(1);
      expect(sessionDeletes[1]).not.toHaveBeenCalled();
    }),
  );

  it.effect("deletes a hosted session before replacing its cached runtime", () =>
    Effect.gen(function* () {
      const { store } = makeSecretStore({ "composio-api-key": "project-key" });

      const { client, createSession, sessionDeletes } = fakeClient({
        accounts: [{ id: "gmail-work", toolkit: { slug: "gmail" }, status: "ACTIVE" }],
      });

      const service = make(store, () => client);

      yield* service.resolveRuntimeMcpServer("thread-1");
      vi.mocked(client.connectedAccounts.list).mockResolvedValue({
        items: [{ id: "slack-work", toolkit: { slug: "slack" }, status: "ACTIVE" }],
        totalPages: 1,
      } as never);
      yield* service.resolveRuntimeMcpServer("thread-1");

      expect(createSession).toHaveBeenCalledTimes(2);
      expect(sessionDeletes[0]).toHaveBeenCalledTimes(1);
      expect(sessionDeletes[1]).not.toHaveBeenCalled();
    }),
  );

  it.effect("keeps failed hosted-session cleanup retryable", () =>
    Effect.gen(function* () {
      const { store, values } = makeSecretStore({ "composio-api-key": "project-key" });

      const { client, sessionDeletes } = fakeClient({
        accounts: [{ id: "gmail-work", toolkit: { slug: "gmail" }, status: "ACTIVE" }],
      });

      const service = make(store, () => client);

      yield* service.resolveRuntimeMcpServer("thread-1");
      sessionDeletes[0]!.mockRejectedValueOnce(new Error("cleanup failed"));

      const error = yield* Effect.flip(service.remove);
      expect(error).toMatchObject({
        operation: "delete hosted tool sessions",
        message: "Composio could not delete hosted tool sessions.",
      });
      expect(values.has("composio-api-key")).toBe(true);

      expect(yield* service.remove).toEqual({ configured: false, connections: [] });
      expect(sessionDeletes[0]).toHaveBeenCalledTimes(2);
      expect(values.has("composio-api-key")).toBe(false);
    }),
  );

  it.effect("deletes the oldest hosted session before LRU eviction", () =>
    Effect.gen(function* () {
      const { store } = makeSecretStore({ "composio-api-key": "project-key" });

      const { client, createSession, sessionDeletes } = fakeClient({
        accounts: [{ id: "gmail-work", toolkit: { slug: "gmail" }, status: "ACTIVE" }],
      });

      const service = make(store, () => client);

      for (let index = 0; index <= 100; index += 1) {
        yield* service.resolveRuntimeMcpServer(`thread-${index}`);
      }

      expect(createSession).toHaveBeenCalledTimes(101);
      expect(sessionDeletes[0]).toHaveBeenCalledTimes(1);
      expect(sessionDeletes[1]).not.toHaveBeenCalled();
    }),
  );

  it.effect("deletes a runtime session created while an account is disconnected", () =>
    Effect.gen(function* () {
      let releaseSessionCreation!: () => void;

      const sessionCreationGate = new Promise<void>((resolve) => {
        releaseSessionCreation = resolve;
      });

      const { store } = makeSecretStore({ "composio-api-key": "project-key" });

      const { client, createSession, sessionDeletes } = fakeClient({
        accounts: [{ id: "gmail-work", toolkit: { slug: "gmail" }, status: "ACTIVE" }],
        sessionCreationGate,
      });

      const service = make(store, () => client);

      const resolving = yield* Effect.forkChild(service.resolveRuntimeMcpServer("thread-1"));
      yield* Effect.promise(() => vi.waitFor(() => expect(createSession).toHaveBeenCalledTimes(1)));
      yield* service.disconnect("gmail-work");
      releaseSessionCreation();

      expect(yield* Fiber.join(resolving)).toBeUndefined();
      expect(sessionDeletes[0]).toHaveBeenCalledTimes(1);
    }),
  );

  it.effect("shares concurrent runtime resolution for the same resource", () =>
    Effect.gen(function* () {
      let releaseSessionCreation!: () => void;

      const sessionCreationGate = new Promise<void>((resolve) => {
        releaseSessionCreation = resolve;
      });

      const { store } = makeSecretStore({ "composio-api-key": "project-key" });

      const { client, createSession, sessionDeletes } = fakeClient({
        accounts: [{ id: "gmail-work", toolkit: { slug: "gmail" }, status: "ACTIVE" }],
        sessionCreationGate,
      });

      const createClient = vi.fn(() => client);
      const service = make(store, createClient);

      const first = yield* Effect.forkChild(service.resolveRuntimeMcpServer("thread-1"));
      yield* Effect.promise(() => vi.waitFor(() => expect(createSession).toHaveBeenCalledTimes(1)));
      const second = yield* Effect.forkChild(service.resolveRuntimeMcpServer("thread-1"));
      yield* Effect.promise(() => vi.waitFor(() => expect(createClient).toHaveBeenCalledTimes(2)));
      releaseSessionCreation();

      expect(yield* Fiber.join(first)).toBe(yield* Fiber.join(second));
      expect(createSession).toHaveBeenCalledTimes(1);
      yield* service.remove;
      expect(sessionDeletes[0]).toHaveBeenCalledTimes(1);
    }),
  );

  it.effect("starts a new runtime resolution after configuration changes", () =>
    Effect.gen(function* () {
      let releaseOldSessionCreation!: () => void;

      const oldSessionCreationGate = new Promise<void>((resolve) => {
        releaseOldSessionCreation = resolve;
      });

      const { store } = makeSecretStore({ "composio-api-key": "old-key" });

      const { client, createSession, sessionDeletes } = fakeClient({
        accounts: [{ id: "gmail-work", toolkit: { slug: "gmail" }, status: "ACTIVE" }],
        sessionCreationGates: [oldSessionCreationGate, Promise.resolve()],
      });

      const service = make(store, () => client);

      const oldResolution = yield* Effect.forkChild(service.resolveRuntimeMcpServer("thread-1"));
      yield* Effect.promise(() => vi.waitFor(() => expect(createSession).toHaveBeenCalledTimes(1)));
      yield* service.configure("new-key");

      expect(yield* service.resolveRuntimeMcpServer("thread-1")).toBeDefined();
      expect(createSession).toHaveBeenCalledTimes(2);
      releaseOldSessionCreation();
      expect(yield* Fiber.join(oldResolution)).toBeUndefined();

      yield* service.remove;
      expect(sessionDeletes).toHaveLength(2);
      expect(sessionDeletes[0]).toHaveBeenCalledTimes(1);
      expect(sessionDeletes[1]).toHaveBeenCalledTimes(1);
    }),
  );
});