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.

20.6 KB
Raw Blame
import * as Predicate from "effect/Predicate";
import * as NodeCrypto from "node:crypto";
import * as NodeFS from "node:fs";
import * as NodeOS from "node:os";
import * as NodePath from "node:path";
import {
  AkeruMemoryTenantId,
  AkeruMemoryUserId,
  BotId,
  ProviderDriverKind,
  ProjectId,
  type AkeruMemoryRevision,
} from "@akeru/contracts";
import { it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as Stream from "effect/Stream";
import { assert, describe, expect, vi } from "vite-plus/test";
import { ServerSettingsService } from "../../serverSettings.ts";
import { BotMemoryStore } from "../../memory/BotMemory.ts";
import * as McpMemoryToolSession from "../../mcp/McpMemoryToolSession.ts";
import { AgentController } from "../Services/AgentController.ts";
import {
  codexThreadId,
  claudeThreadId,
  codexInstanceId,
  openCodeInstanceId,
  codexSelection,
} from "./test-support/agentControllerFixtures.ts";
import {
  MemoryToolCallError,
  privatePolicyRevisions,
  entityMemorySection,
  makeMemoryOnlyCredentialOptions,
} from "./test-support/agentControllerMemory.ts";
import {
  makeProviderSession,
  makeBridge,
  provideController,
  resolveCodex,
} from "./test-support/agentControllerLayers.ts";
import { mastraHarnessFixture } from "./test-support/agentControllerHarness.ts";

describe("AgentControllerLive", () => {
  it.effect("reads entity memory for the access of a reused Mastra session", () => {
    const bridge = makeBridge();
    const mastra = mastraHarnessFixture();
    const memoryDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "akeru-entity-reuse-"));
    const botMemoryStore = new BotMemoryStore(memoryDir);
    const botId = BotId.make("bot-entity-reuse");

    const accessFor = (project: string) =>
      ({
        tenantId: AkeruMemoryTenantId.make("local"),
        userId: AkeruMemoryUserId.make("owner"),
        threadId: codexThreadId,
        projectId: ProjectId.make(project),
        workspaceRoot: "/workspace/entity-reuse",
        botId,
        groupId: null,
        respondingBotId: botId,
        groupMemberBotIds: [],
      }) as const;

    const listedProjects: Array<string | null> = [];

    const listCurrent = vi.fn((input: { readonly access: { readonly projectId: unknown } }) => {
      listedProjects.push(String(input.access.projectId));

      return Effect.succeed([]);
    });

    const recordDerivedCopies = vi.fn(() => Effect.void);

    return provideController(
      Effect.gen(function* () {
        const controller = yield* AgentController;
        yield* resolveCodex(controller);

        const start = (project: string) =>
          controller.startSession(codexThreadId, {
            threadId: codexThreadId,
            provider: ProviderDriverKind.make("codex"),
            providerInstanceId: codexInstanceId,
            modelSelection: codexSelection,
            runtimeMode: "full-access",
            memoryAccess: accessFor(project),
          });

        yield* start("project-before");
        yield* start("project-after");
        listedProjects.length = 0;
        yield* controller.sendTurn({ threadId: codexThreadId, input: "Use current memory." });
        yield* Effect.promise(() => mastra.waitForSendMessageCount(1));
        mastra.finishSend();
        yield* Effect.yieldNow;
        expect(listedProjects).toContain("project-after");
        expect(listedProjects).not.toContain("project-before");
      }),
      bridge.service,
      mastra.factory,
      undefined,
      undefined,
      undefined,
      { botMemoryStore, entityMemoryRepository: { listCurrent, recordDerivedCopies } as never },
    ).pipe(
      Effect.ensuring(
        Effect.sync(() => NodeFS.rmSync(memoryDir, { recursive: true, force: true })),
      ),
    );
  });
});

describe("AgentControllerLive", () => {
  it.effect("keeps entity memory out of a new legacy session while Memory is off", () => {
    const bridge = makeBridge();
    const mastra = mastraHarnessFixture();
    const botId = BotId.make("bot-entity-memory-off");

    const access = {
      tenantId: AkeruMemoryTenantId.make("local"),
      userId: AkeruMemoryUserId.make("owner"),
      threadId: claudeThreadId,
      projectId: ProjectId.make("project-entity-memory-off"),
      workspaceRoot: "/workspace/entity-memory-off",
      botId,
      groupId: null,
      respondingBotId: botId,
      groupMemberBotIds: [],
    } as const;

    const listCurrent = vi.fn(() => Effect.succeed([]));
    // Only the entity packet records derived copies; the legacy migration read also lists facts.
    const recordDerivedCopies = vi.fn(() => Effect.void);

    return provideController(
      Effect.gen(function* () {
        const controller = yield* AgentController;
        const settings = yield* ServerSettingsService;
        yield* settings.updateSettings({ memory: { enabled: false } });
        yield* controller.resolveEngine({
          threadId: claudeThreadId,
          engine: { provider: "opencode", model: "anthropic/claude-sonnet-4-5" },
          fallback: codexSelection,
          mode: "default",
          botConversation: true,
        });
        yield* controller.startSession(claudeThreadId, {
          threadId: claudeThreadId,
          provider: ProviderDriverKind.make("opencode"),
          providerInstanceId: openCodeInstanceId,
          cwd: process.cwd(),
          runtimeMode: "approval-required",
          memoryAccess: access,
        });
        expect(recordDerivedCopies).not.toHaveBeenCalled();
        expect(bridge.startSession.mock.calls[0]?.[1].persistentMemoryContext).toBeUndefined();
      }),
      bridge.service,
      mastra.factory,
      undefined,
      undefined,
      undefined,
      {
        ...makeMemoryOnlyCredentialOptions(),
        entityMemoryRepository: { listCurrent, recordDerivedCopies } as never,
      },
    );
  });
});

describe("AgentControllerLive", () => {
  it.effect("reads entity memory from the current project after reusing a legacy session", () => {
    const bridge = makeBridge();
    const mastra = mastraHarnessFixture();
    const botId = BotId.make("bot-entity-memory-moved");

    const accessFor = (project: string) =>
      ({
        tenantId: AkeruMemoryTenantId.make("local"),
        userId: AkeruMemoryUserId.make("owner"),
        threadId: claudeThreadId,
        projectId: ProjectId.make(project),
        workspaceRoot: "/workspace/entity-memory-moved",
        botId,
        groupId: null,
        respondingBotId: botId,
        groupMemberBotIds: [],
      }) as const;

    const listCurrent = vi.fn((_input: { access: { projectId: ProjectId } }) => Effect.succeed([]));

    const startSession = (project: string) =>
      Effect.gen(function* () {
        const controller = yield* AgentController;

        return yield* controller.startSession(claudeThreadId, {
          threadId: claudeThreadId,
          provider: ProviderDriverKind.make("opencode"),
          providerInstanceId: openCodeInstanceId,
          cwd: process.cwd(),
          runtimeMode: "approval-required",
          memoryAccess: accessFor(project),
        });
      });

    return provideController(
      Effect.gen(function* () {
        const controller = yield* AgentController;
        yield* controller.resolveEngine({
          threadId: claudeThreadId,
          engine: { provider: "opencode", model: "anthropic/claude-sonnet-4-5" },
          fallback: codexSelection,
          mode: "default",
          botConversation: true,
        });
        yield* startSession("project-before-move");
        yield* startSession("project-after-move");
        expect(bridge.startSession).toHaveBeenCalledTimes(1);
        listCurrent.mockClear();

        yield* controller.sendTurn({ threadId: claudeThreadId, input: "After the move." });
        expect(listCurrent.mock.calls.map(([input]) => String(input.access.projectId))).toEqual([
          "project-after-move",
        ]);
      }),
      {
        ...bridge.service,
        listSessions: () => Effect.succeed([makeProviderSession(claudeThreadId, "opencode")]),
      },
      mastra.factory,
      undefined,
      undefined,
      undefined,
      {
        ...makeMemoryOnlyCredentialOptions(),
        entityMemoryRepository: { listCurrent, recordDerivedCopies: () => Effect.void } as never,
      },
    );
  });
});

describe("AgentControllerLive", () => {
  it.effect(
    "withholds bot-private entity facts on the legacy path while Private bot memory is off",
    () => {
      const bridge = makeBridge();
      const mastra = mastraHarnessFixture();
      const botId = BotId.make("bot-entity-private-legacy");
      const projectId = ProjectId.make("project-entity-private-legacy");

      const access = {
        tenantId: AkeruMemoryTenantId.make("local"),
        userId: AkeruMemoryUserId.make("owner"),
        threadId: claudeThreadId,
        projectId,
        workspaceRoot: "/workspace/entity-private-legacy",
        botId,
        groupId: null,
        respondingBotId: botId,
        groupMemberBotIds: [],
      } as const;

      const revisions = privatePolicyRevisions(botId, projectId);
      const listCurrent = vi.fn(() => Effect.succeed(revisions));

      const recordDerivedCopies = vi.fn(
        (_input: { readonly revisions: ReadonlyArray<AkeruMemoryRevision> }) => Effect.void,
      );

      return provideController(
        Effect.gen(function* () {
          const controller = yield* AgentController;
          const settings = yield* ServerSettingsService;
          yield* settings.updateSettings({ memory: { privateBotMemory: false } });
          yield* controller.resolveEngine({
            threadId: claudeThreadId,
            engine: { provider: "opencode", model: "anthropic/claude-sonnet-4-5" },
            fallback: codexSelection,
            mode: "default",
            botConversation: true,
          });
          yield* controller.startSession(claudeThreadId, {
            threadId: claudeThreadId,
            provider: ProviderDriverKind.make("opencode"),
            providerInstanceId: openCodeInstanceId,
            cwd: process.cwd(),
            runtimeMode: "approval-required",
            memoryAccess: access,
          });

          const startPacket = entityMemorySection(
            bridge.startSession.mock.calls[0]?.[1].persistentMemoryContext,
          );

          expect(startPacket).toContain("Shared project entity fact.");
          expect(startPacket).not.toContain("Bot-private entity fact.");
          expect(startPacket).not.toContain("Bot-about-you entity fact.");

          yield* controller.sendTurn({ threadId: claudeThreadId, input: "Private off." });

          const offPacket = entityMemorySection(
            bridge.sendTurn.mock.calls[0]?.[0].persistentMemoryContext,
          );

          expect(offPacket).toContain("Shared project entity fact.");
          expect(offPacket).not.toContain("Bot-private entity fact.");
          expect(offPacket).not.toContain("Bot-about-you entity fact.");

          // Derived copies track only what reached the provider.
          for (const [input] of recordDerivedCopies.mock.calls) {
            expect(input.revisions.map((revision) => revision.partition.scope)).toEqual([
              "project",
            ]);
          }

          yield* settings.updateSettings({ memory: { privateBotMemory: true } });
          yield* controller.sendTurn({ threadId: claudeThreadId, input: "Private on." });

          const onPacket = entityMemorySection(
            bridge.sendTurn.mock.calls[1]?.[0].persistentMemoryContext,
          );

          expect(onPacket).toContain("Bot-private entity fact.");
          expect(onPacket).toContain("Bot-about-you entity fact.");
        }),
        {
          ...bridge.service,
          listSessions: () => Effect.succeed([makeProviderSession(claudeThreadId, "opencode")]),
        },
        mastra.factory,
        undefined,
        undefined,
        undefined,
        {
          ...makeMemoryOnlyCredentialOptions(),
          entityMemoryRepository: { listCurrent, recordDerivedCopies } as never,
        },
      );
    },
  );
});

describe("AgentControllerLive", () => {
  it.effect(
    "withholds bot-private entity facts on the Mastra path while Private bot memory is off",
    () => {
      const bridge = makeBridge();
      const mastra = mastraHarnessFixture();
      const memoryDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "akeru-entity-private-"));
      const botMemoryStore = new BotMemoryStore(memoryDir);
      const botId = BotId.make("bot-entity-private-mastra");
      const projectId = ProjectId.make("project-entity-private-mastra");

      const access = {
        tenantId: AkeruMemoryTenantId.make("local"),
        userId: AkeruMemoryUserId.make("owner"),
        threadId: codexThreadId,
        projectId,
        workspaceRoot: "/workspace/entity-private-mastra",
        botId,
        groupId: null,
        respondingBotId: botId,
        groupMemberBotIds: [],
      } as const;

      const revisions = privatePolicyRevisions(botId, projectId);
      const listCurrent = vi.fn(() => Effect.succeed(revisions));
      const recordDerivedCopies = vi.fn(() => Effect.void);

      return provideController(
        Effect.gen(function* () {
          const controller = yield* AgentController;
          const settings = yield* ServerSettingsService;
          yield* resolveCodex(controller);
          yield* controller.startSession(codexThreadId, {
            threadId: codexThreadId,
            provider: ProviderDriverKind.make("codex"),
            providerInstanceId: codexInstanceId,
            modelSelection: codexSelection,
            runtimeMode: "full-access",
            memoryAccess: access,
          });

          const awaitNextCompletedTurn = () =>
            controller.streamEvents.pipe(
              Stream.filter((event) => event.type === "turn.completed"),
              Stream.runHead,
              Effect.forkChild({ startImmediately: true }),
            );

          yield* settings.updateSettings({ memory: { privateBotMemory: false } });
          const offTurn = yield* awaitNextCompletedTurn();
          yield* controller.sendTurn({ threadId: codexThreadId, input: "Private off." });
          yield* Effect.promise(() => mastra.waitForSendMessageCount(1));
          const offPacket = entityMemorySection(mastra.session.state.get().persistentMemoryContext);
          expect(offPacket).toContain("Shared project entity fact.");
          expect(offPacket).not.toContain("Bot-private entity fact.");
          expect(offPacket).not.toContain("Bot-about-you entity fact.");
          mastra.finishSend();
          yield* Fiber.join(offTurn);

          yield* settings.updateSettings({ memory: { privateBotMemory: true } });
          yield* controller.sendTurn({ threadId: codexThreadId, input: "Private on." });
          yield* Effect.promise(() => mastra.waitForSendMessageCount(2));
          const onPacket = entityMemorySection(mastra.session.state.get().persistentMemoryContext);
          expect(onPacket).toContain("Bot-private entity fact.");
          expect(onPacket).toContain("Bot-about-you entity fact.");
          mastra.finishSend();
          yield* Effect.yieldNow;
        }),
        bridge.service,
        mastra.factory,
        undefined,
        undefined,
        undefined,
        { botMemoryStore, entityMemoryRepository: { listCurrent, recordDerivedCopies } as never },
      ).pipe(
        Effect.ensuring(
          Effect.sync(() => NodeFS.rmSync(memoryDir, { recursive: true, force: true })),
        ),
      );
    },
  );
});

describe("AgentControllerLive", () => {
  it.effect("applies the Private bot memory toggle mid-session on the legacy path", () => {
    const bridge = makeBridge();
    const mastra = mastraHarnessFixture();
    const memoryDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "akeru-private-toggle-"));
    const botMemoryStore = new BotMemoryStore(memoryDir);
    const botId = BotId.make("bot-private-toggle-legacy");

    const access = {
      tenantId: AkeruMemoryTenantId.make("local"),
      userId: AkeruMemoryUserId.make("owner"),
      threadId: claudeThreadId,
      projectId: ProjectId.make("project-private-toggle-legacy"),
      workspaceRoot: "/workspace/private-toggle-legacy",
      botId,
      groupId: null,
      respondingBotId: botId,
      groupMemberBotIds: [],
    } as const;

    const credentials = makeMemoryOnlyCredentialOptions();

    const callMemoryTool = (input: {
      target: string;
      operations: Array<unknown>;
      share?: { fact: string; scope: string };
    }) =>
      Effect.tryPromise({
        try: () => {
          const handler = McpMemoryToolSession.readMcpMemoryToolSession(claudeThreadId);
          assert.isDefined(handler);

          return handler({
            threadId: String(claudeThreadId),
            toolId: "memory",
            toolCallId: `mcp-memory-${NodeCrypto.randomUUID()}`,
            input,
            approvalMode: "require-grant",
          });
        },
        catch: (cause) =>
          new MemoryToolCallError({
            cause: cause instanceof Error ? cause : new Error(String(cause)),
          }),
      });

    return provideController(
      Effect.gen(function* () {
        const controller = yield* AgentController;
        const settings = yield* ServerSettingsService;
        yield* controller.resolveEngine({
          threadId: claudeThreadId,
          engine: { provider: "opencode", model: "anthropic/claude-sonnet-4-5" },
          fallback: codexSelection,
          mode: "default",
          botConversation: true,
        });
        yield* Effect.promise(() =>
          botMemoryStore.mutate({
            ...access,
            target: "memory",
            operations: [{ action: "add", content: "Bot-private note." }],
          }),
        );
        yield* controller.startSession(claudeThreadId, {
          threadId: claudeThreadId,
          provider: ProviderDriverKind.make("opencode"),
          providerInstanceId: openCodeInstanceId,
          cwd: process.cwd(),
          runtimeMode: "approval-required",
          memoryAccess: access,
        });

        const privateRead = yield* callMemoryTool({ target: "memory", operations: [] });
        expect(privateRead).toMatchObject({ success: true, content: "Bot-private note." });

        // Turning Private bot memory off mid-session removes MEMORY.md from the
        // prompt and denies the bot-private target on the existing handler.
        yield* settings.updateSettings({ memory: { privateBotMemory: false } });
        yield* controller.sendTurn({ threadId: claudeThreadId, input: "Private off turn." });
        expect(bridge.sendTurn).toHaveBeenCalledTimes(1);
        const context = bridge.sendTurn.mock.calls[0]?.[0].persistentMemoryContext ?? "";
        expect(context).not.toContain("<bot-memory>");
        expect(context).not.toContain("Bot-private note.");

        const denied = yield* callMemoryTool({ target: "memory", operations: [] }).pipe(
          Effect.result,
        );

        assert.equal(denied._tag, "Failure");
        expect(Predicate.isTagged(denied, "Failure") ? denied.failure.cause.message : "").toContain(
          "Private bot memory is disabled.",
        );

        // A share-only call names the memory target but never touches MEMORY.md,
        // so it passes the Private bot memory gate and reaches the share path
        // (this fixture has no approvals service).
        const shareOnly = yield* callMemoryTool({
          target: "memory",
          operations: [],
          share: { fact: "The project uses pnpm.", scope: "project" },
        }).pipe(Effect.result);

        expect(
          Predicate.isTagged(shareOnly, "Failure") ? shareOnly.failure.cause.message : "",
        ).toBe("Shared memory is not available in this chat.");
        const userStillAllowed = yield* callMemoryTool({ target: "user", operations: [] });
        expect(userStillAllowed).toMatchObject({ success: true });

        yield* settings.updateSettings({ memory: { privateBotMemory: true } });
        const restoredRead = yield* callMemoryTool({ target: "memory", operations: [] });
        expect(restoredRead).toMatchObject({ success: true, content: "Bot-private note." });
        yield* controller.sendTurn({ threadId: claudeThreadId, input: "Private on again." });
        expect(bridge.sendTurn.mock.calls[1]?.[0].persistentMemoryContext).toContain(
          "Bot-private note.",
        );
      }),
      bridge.service,
      mastra.factory,
      undefined,
      undefined,
      undefined,
      { botMemoryStore, ...credentials },
    ).pipe(
      Effect.ensuring(
        Effect.sync(() => {
          McpMemoryToolSession.clearMcpMemoryToolSession(claudeThreadId);
          NodeFS.rmSync(memoryDir, { recursive: true, force: true });
        }),
      ),
    );
  });
});