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.

7.4 KB
Raw Blame
import * as NodeFS from "node:fs";
import * as NodePath from "node:path";
import { ProviderDriverKind } from "@akeru/contracts";
import { CommandId, EventId, MessageId, ThreadId } from "@akeru/contracts";
import * as Effect from "effect/Effect";
import { afterEach, describe, expect, it } from "vite-plus/test";
import { checkpointRefForThreadTurn } from "../../checkpointing/Utils.ts";
import {
  asTurnId,
  waitForGitRefExists,
  waitForEvent,
  waitForThread,
  gitRefExists,
  gitShowFileAtRef,
  createCheckpointHarness,
} from "./test-support/CheckpointHarness.ts";

describe("CheckpointReactor", () => {
  const testScope = createCheckpointHarness();
  const { createHarness } = testScope;
  afterEach(testScope.dispose);
  it("captures pre-turn baseline on turn.started and post-turn checkpoint on turn.completed", async () => {
    const harness = await createHarness({ seedFilesystemCheckpoints: false });
    const createdAt = "2026-01-01T00:00:00.000Z";

    await harness.run(
      harness.engine.dispatch({
        type: "thread.session.set",
        commandId: CommandId.make("cmd-session-set-capture"),
        threadId: ThreadId.make("thread-1"),
        session: {
          threadId: ThreadId.make("thread-1"),
          status: "ready",
          providerName: "codex",
          runtimeMode: "approval-required",
          activeTurnId: null,
          lastError: null,
          updatedAt: createdAt,
        },
        createdAt,
      }),
    );

    harness.provider.emit({
      type: "turn.started",
      eventId: EventId.make("evt-turn-started-1"),
      provider: ProviderDriverKind.make("codex"),

      createdAt: "2026-01-01T00:00:00.000Z",
      threadId: ThreadId.make("thread-1"),
      turnId: asTurnId("turn-1"),
    });
    await waitForGitRefExists(
      harness,
      harness.cwd,
      checkpointRefForThreadTurn(ThreadId.make("thread-1"), 0),
    );

    NodeFS.writeFileSync(NodePath.join(harness.cwd, "README.md"), "v2\n", "utf8");
    harness.provider.emit({
      type: "turn.completed",
      eventId: EventId.make("evt-turn-completed-1"),
      provider: ProviderDriverKind.make("codex"),

      createdAt: "2026-01-01T00:00:00.000Z",
      threadId: ThreadId.make("thread-1"),
      turnId: asTurnId("turn-1"),
      payload: { state: "completed" },
    });

    await waitForEvent(harness, (event) => event.type === "thread.turn-diff-completed");

    const thread = await waitForThread(
      harness,
      (entry) => entry.latestTurn?.turnId === "turn-1" && entry.checkpoints.length === 1,
    );

    expect(thread.checkpoints[0]?.checkpointTurnCount).toBe(1);
    expect(
      gitRefExists(harness.cwd, checkpointRefForThreadTurn(ThreadId.make("thread-1"), 0)),
    ).toBe(true);
    expect(
      gitRefExists(harness.cwd, checkpointRefForThreadTurn(ThreadId.make("thread-1"), 1)),
    ).toBe(true);
    expect(
      gitShowFileAtRef(
        harness.cwd,
        checkpointRefForThreadTurn(ThreadId.make("thread-1"), 0),
        "README.md",
      ),
    ).toBe("v1\n");
    expect(
      gitShowFileAtRef(
        harness.cwd,
        checkpointRefForThreadTurn(ThreadId.make("thread-1"), 1),
        "README.md",
      ),
    ).toBe("v2\n");
  });

  it("links a completion checkpoint to the newest assistant message of its turn", async () => {
    const harness = await createHarness({ seedFilesystemCheckpoints: false });
    const threadId = ThreadId.make("thread-1");
    const createdAt = "2026-01-01T00:00:00.000Z";

    const assistantMessages = [
      { id: "assistant-turn-1-first", turnId: "turn-1", at: "2026-01-01T00:00:01.000Z" },
      { id: "assistant-turn-1-latest", turnId: "turn-1", at: "2026-01-01T00:00:02.000Z" },
      { id: "assistant-other-turn", turnId: "turn-other", at: "2026-01-01T00:00:03.000Z" },
    ] as const;

    await harness.run(
      Effect.gen(function* () {
        yield* harness.engine.dispatch({
          type: "thread.session.set",
          commandId: CommandId.make("cmd-session-set-assistant-link"),
          threadId,
          session: {
            threadId,
            status: "ready",
            providerName: "codex",
            runtimeMode: "approval-required",
            activeTurnId: null,
            lastError: null,
            updatedAt: createdAt,
          },
          createdAt,
        });
        harness.provider.emit({
          type: "turn.started",
          eventId: EventId.make("evt-turn-started-assistant-link"),
          provider: ProviderDriverKind.make("codex"),
          createdAt,
          threadId,
          turnId: asTurnId("turn-1"),
        });
        yield* Effect.promise(() =>
          waitForGitRefExists(harness, harness.cwd, checkpointRefForThreadTurn(threadId, 0)),
        );

        for (const message of assistantMessages) {
          yield* harness.engine.dispatch({
            type: "thread.message.assistant.delta",
            commandId: CommandId.make(`cmd-delta-${message.id}`),
            threadId,
            messageId: MessageId.make(message.id),
            delta: message.id,
            turnId: asTurnId(message.turnId),
            createdAt: message.at,
          });
          yield* harness.engine.dispatch({
            type: "thread.message.assistant.complete",
            commandId: CommandId.make(`cmd-complete-${message.id}`),
            threadId,
            messageId: MessageId.make(message.id),
            turnId: asTurnId(message.turnId),
            createdAt: message.at,
          });
        }
      }),
    );

    NodeFS.writeFileSync(NodePath.join(harness.cwd, "README.md"), "v2\n", "utf8");
    harness.provider.emit({
      type: "turn.completed",
      eventId: EventId.make("evt-turn-completed-assistant-link"),
      provider: ProviderDriverKind.make("codex"),
      createdAt: "2026-01-01T00:00:04.000Z",
      threadId,
      turnId: asTurnId("turn-1"),
      payload: { state: "completed" },
    });

    const events = await waitForEvent(
      harness,
      (event) => event.type === "thread.turn-diff-completed",
    );

    const diffCompleted = events.find((event) => event.type === "thread.turn-diff-completed");
    expect(
      diffCompleted?.type === "thread.turn-diff-completed"
        ? diffCompleted.payload.assistantMessageId
        : undefined,
    ).toBe("assistant-turn-1-latest");
  });

  it("does not capture a checkpoint for imported conversation history", async () => {
    const harness = await createHarness({
      hasSession: false,
      seedFilesystemCheckpoints: false,
      threadWorktreePath: null,
    });

    const createdAt = "2026-01-01T00:00:00.000Z";

    await testScope.runtime!.runPromise(
      harness.engine.dispatch({
        type: "thread.history.restore",
        commandId: CommandId.make("cmd-import-history"),
        threadId: ThreadId.make("thread-1"),
        messages: [
          {
            id: MessageId.make("message-imported"),
            role: "user",
            text: "Imported history",
            turnId: null,
            streaming: false,
            createdAt,
            updatedAt: createdAt,
          },
        ],
        proposedPlans: [],
        activities: [],
        settledOverride: null,
        settledAt: null,
        snoozedUntil: null,
        snoozedAt: null,
        pinnedAt: null,
        pinOrderKey: null,
        archivedAt: null,
        updatedAt: createdAt,
      }),
    );
    await harness.drain();

    expect(
      gitRefExists(harness.cwd, checkpointRefForThreadTurn(ThreadId.make("thread-1"), 0)),
    ).toBe(false);
  });
});