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.

11.3 KB
Raw Blame
import { workspaceIO } from "./test-support/workspaceIO.ts";
import { describe } from "vite-plus/test";
import * as NodeFS from "node:fs";
import { BotId } from "@akeru/contracts";
import { afterEach, expect, it, vi } from "vite-plus/test";
import { AkeruSessionResources } from "./AkeruSessionResources.ts";
import { makeAkeruSessionResourcesTestSupport } from "./test-support/AkeruSessionResources.ts";

const { directories, stateDir, workspace, localBotWorkspace, browser, remoteInput } =
  makeAkeruSessionResourcesTestSupport();

describe("AkeruSessionResources", () => {
  afterEach(() => {
    for (const directory of directories) {
      NodeFS.rmSync(directory, { recursive: true, force: true });
    }

    directories.clear();
  });

  it("shares one workspace and browser across thread sessions", async () => {
    const remote = workspace();
    const makeRemoteWorkspace = vi.fn(async () => localBotWorkspace(remote));
    const sharedBrowser = browser();
    const makeBotBrowser = vi.fn(() => sharedBrowser);

    const resources = new AkeruSessionResources({
      io: workspaceIO,
      stateDir: stateDir(),
      makeRemoteWorkspace,
      makeBotBrowser,
      toMcpServerConfigs: () => ({}),
    });

    const first = await resources.acquire({ ...remoteInput, threadId: "first" });
    const second = await resources.acquire({ ...remoteInput, threadId: "second" });
    expect(first.workspace).toBe(second.workspace);
    expect(makeRemoteWorkspace).toHaveBeenCalledOnce();
    expect(makeBotBrowser).toHaveBeenCalledOnce();

    await resources.release("first");
    await resources.release("second");
    await resources.acquire({ ...remoteInput, threadId: "third" });
    expect(sharedBrowser.reconnect).toHaveBeenCalledOnce();
    await resources.shutdown();
    expect(sharedBrowser.close).toHaveBeenCalledOnce();
  });

  it("attributes shared browser failures and recovery to every active bot", async () => {
    const browserFailure = vi.fn();
    const browserReady = vi.fn();
    let onFailure!: (cause: unknown) => void;
    let onReady!: () => void;
    const sharedBrowser = browser();

    const resources = new AkeruSessionResources({
      io: workspaceIO,
      stateDir: stateDir(),
      makeBotBrowser: (input) => {
        onFailure = input.onFailure!;
        onReady = input.onReady!;

        return sharedBrowser;
      },
      onBrowserFailure: browserFailure,
      onBrowserReady: browserReady,
      toMcpServerConfigs: () => ({}),
    });

    const first = {
      ...remoteInput,
      botSandbox: null,
      threadId: "bot-a",
      botId: BotId.make("bot-a"),
      botName: "A",
      taskOrRoutine: "Task A",
    };

    const second = {
      ...remoteInput,
      botSandbox: null,
      threadId: "bot-b",
      botId: BotId.make("bot-b"),
      botName: "B",
      taskOrRoutine: "Task B",
    };

    await resources.acquire(first);
    await resources.acquire(second);
    onFailure(new Error("browser exited"));
    expect(browserFailure.mock.calls.map(([value]) => value.botId)).toEqual([
      first.botId,
      second.botId,
    ]);
    onReady();
    expect(browserReady.mock.calls.map(([botId]) => botId)).toEqual([first.botId, second.botId]);
    await resources.shutdown();
  });

  it("reports an active shared-browser failure to a bot that joins later", async () => {
    const browserFailure = vi.fn();
    const browserReady = vi.fn();
    let onFailure!: (cause: unknown) => void;
    let onReady!: () => void;

    const resources = new AkeruSessionResources({
      io: workspaceIO,
      stateDir: stateDir(),
      makeBotBrowser: (input) => {
        onFailure = input.onFailure!;
        onReady = input.onReady!;

        return browser();
      },
      onBrowserFailure: browserFailure,
      onBrowserReady: browserReady,
      toMcpServerConfigs: () => ({}),
    });

    const first = {
      ...remoteInput,
      botSandbox: null,
      threadId: "late-share-first",
      botId: BotId.make("late-share-first"),
    };

    const second = {
      ...remoteInput,
      botSandbox: null,
      threadId: "late-share-second",
      botId: BotId.make("late-share-second"),
    };

    await resources.acquire(first);
    onFailure(new Error("browser exited"));
    expect(browserFailure).toHaveBeenCalledOnce();
    await resources.acquire(second);
    expect(browserFailure.mock.calls.map(([input]) => input.botId)).toEqual([
      first.botId,
      second.botId,
    ]);
    onReady();
    expect(browserReady.mock.calls.map(([botId]) => botId)).toEqual([first.botId, second.botId]);
    await resources.shutdown();
  });

  it("does not pass a discarded browser failure to a replacement browser's bot", async () => {
    const browserFailure = vi.fn();
    const callbacks: Array<(cause: unknown) => void> = [];

    const makeBotBrowser = vi.fn((input: { onFailure?: (cause: unknown) => void }) => {
      callbacks.push(input.onFailure!);

      return browser();
    });

    const resources = new AkeruSessionResources({
      io: workspaceIO,
      stateDir: stateDir(),
      makeBotBrowser,
      onBrowserFailure: browserFailure,
      toMcpServerConfigs: () => ({}),
    });

    const first = {
      ...remoteInput,
      botSandbox: null,
      threadId: "discarded-browser",
      botId: BotId.make("bot-a"),
    };

    const second = {
      ...first,
      threadId: "replacement-browser",
      botId: BotId.make("bot-b"),
    };

    await resources.acquire(first);
    callbacks[0]!(new Error("browser exited"));
    expect(browserFailure).toHaveBeenCalledOnce();
    await resources.release(first.threadId, { destroy: true });
    await resources.acquire(second);

    expect(makeBotBrowser).toHaveBeenCalledTimes(2);
    callbacks[0]!(new Error("old request rejected after replacement"));
    expect(browserFailure).toHaveBeenCalledOnce();
    await resources.shutdown();
  });

  it("removes a stale browser when reconnect fails", async () => {
    const firstBrowser = browser({
      reconnect: async () => Promise.reject(new Error("reconnect failed")),
    });

    const replacementBrowser = browser();

    const makeBotBrowser = vi
      .fn()
      .mockReturnValueOnce(firstBrowser)
      .mockReturnValueOnce(replacementBrowser);

    const resources = new AkeruSessionResources({
      io: workspaceIO,
      stateDir: stateDir(),
      makeRemoteWorkspace: async () => localBotWorkspace(workspace()),
      makeBotBrowser,
      toMcpServerConfigs: () => ({}),
    });

    await resources.acquire({ ...remoteInput, threadId: "initial" });
    await resources.release("initial");
    await expect(
      resources.acquire({ ...remoteInput, threadId: "failed-reconnect" }),
    ).rejects.toThrow("reconnect failed");
    expect(firstBrowser.close).toHaveBeenCalledOnce();
    expect(resources.getConnectorTools("failed-reconnect")).toEqual({});

    await resources.acquire({ ...remoteInput, threadId: "replacement" });
    expect(makeBotBrowser).toHaveBeenCalledTimes(2);
    await resources.shutdown();
    expect(replacementBrowser.close).toHaveBeenCalledOnce();
  });

  it("replaces the browser and workspace after sleep fails", async () => {
    const failed = workspace();
    vi.spyOn(failed, "stop").mockRejectedValueOnce(new Error("sleep failed"));
    const replacement = workspace();

    const makeRemoteWorkspace = vi
      .fn()
      .mockResolvedValueOnce(localBotWorkspace(failed))
      .mockResolvedValueOnce(localBotWorkspace(replacement));

    const staleBrowser = browser();
    const replacementBrowser = browser();

    const makeBotBrowser = vi
      .fn()
      .mockReturnValueOnce(staleBrowser)
      .mockReturnValueOnce(replacementBrowser);

    const resources = new AkeruSessionResources({
      io: workspaceIO,
      stateDir: stateDir(),
      makeRemoteWorkspace,
      makeBotBrowser,
      toMcpServerConfigs: () => ({}),
    });

    await resources.acquire({ ...remoteInput, threadId: "failed-sleep" });
    await expect(resources.release("failed-sleep")).rejects.toThrow("sleep failed");
    expect(staleBrowser.close).toHaveBeenCalledOnce();

    const acquired = await resources.acquire({ ...remoteInput, threadId: "replacement" });
    expect(acquired.workspace).toBe(replacement);
    expect(makeRemoteWorkspace).toHaveBeenCalledTimes(2);
    expect(makeBotBrowser).toHaveBeenCalledTimes(2);
    await resources.shutdown();
  });

  it("does not leave closed browser tools after a shared reconnect fails", async () => {
    const staleBrowser = browser({
      reconnect: async () => Promise.reject(new Error("shared reconnect failed")),
    });

    const replacementBrowser = browser();

    const makeBotBrowser = vi
      .fn()
      .mockReturnValueOnce(staleBrowser)
      .mockReturnValueOnce(replacementBrowser);

    const resources = new AkeruSessionResources({
      io: workspaceIO,
      stateDir: stateDir(),
      makeRemoteWorkspace: async () => localBotWorkspace(workspace()),
      makeBotBrowser,
      toMcpServerConfigs: () => ({}),
    });

    await resources.acquire({ ...remoteInput, threadId: "initial-shared" });
    await resources.release("initial-shared");

    const reconnects = [
      resources.acquire({ ...remoteInput, threadId: "shared-one" }),
      resources.acquire({ ...remoteInput, threadId: "shared-two" }),
    ];

    await Promise.all(
      reconnects.map((acquire) => expect(acquire).rejects.toThrow("shared reconnect failed")),
    );
    expect(staleBrowser.close).toHaveBeenCalledOnce();

    await resources.acquire({ ...remoteInput, threadId: "shared-replacement" });
    expect(makeBotBrowser).toHaveBeenCalledTimes(2);
    await resources.shutdown();
  });

  it("keeps a destroy request until the final shared browser release", async () => {
    const remote = workspace();
    const destroy = vi.spyOn(remote, "destroy");
    const sharedBrowser = browser();

    const resources = new AkeruSessionResources({
      io: workspaceIO,
      stateDir: stateDir(),
      makeRemoteWorkspace: async () => localBotWorkspace(remote),
      makeBotBrowser: () => sharedBrowser,
      toMcpServerConfigs: () => ({}),
    });

    await resources.acquire({ ...remoteInput, threadId: "first" });
    await resources.acquire({ ...remoteInput, threadId: "second" });

    await resources.release("first", { destroy: true });
    expect(sharedBrowser.close).not.toHaveBeenCalled();
    expect(destroy).not.toHaveBeenCalled();
    await resources.release("second");
    expect(sharedBrowser.close).toHaveBeenCalledOnce();
    expect(destroy).toHaveBeenCalledOnce();
    await resources.shutdown();
  });

  it("stops pooled workspaces and browsers during shutdown", async () => {
    const remote = workspace();
    const stop = vi.spyOn(remote, "stop");
    const destroy = vi.spyOn(remote, "destroy");
    const sharedBrowser = browser();

    const resources = new AkeruSessionResources({
      io: workspaceIO,
      stateDir: stateDir(),
      makeRemoteWorkspace: async () => localBotWorkspace(remote),
      makeBotBrowser: () => sharedBrowser,
      toMcpServerConfigs: () => ({}),
    });

    await resources.acquire({ ...remoteInput, threadId: "shutdown" });
    await resources.release("shutdown");
    expect(stop).toHaveBeenCalledOnce();

    await resources.shutdown();
    expect(destroy).not.toHaveBeenCalled();
    expect(sharedBrowser.close).toHaveBeenCalledOnce();
    await expect(resources.acquire({ ...remoteInput, threadId: "late" })).rejects.toThrow(
      "shutting down",
    );
  });
});