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.

8.3 KB
Raw Blame
import { DEFAULT_SERVER_SETTINGS, ProjectId } from "@akeru/contracts";
import { describe, expect, it } from "vite-plus/test";
import {
  commandsForPortabilityImport,
  createPortabilityArchive,
  isPortabilityPreviewCurrent,
  previewPortabilityImport,
} from "./portability.ts";

import {
  makeSnapshot,
  makeSettings,
  NOW,
  AVAILABLE_PROVIDER_IDS,
  THREAD_ID,
  LATER,
  PROJECT_ID,
  URL_MCP_ID,
  STDIO_MCP_ID,
} from "./portabilityTestSupport.ts";

describe("portability import", () => {
  it("conflicts with different existing conversation history", () => {
    const source = makeSnapshot();

    const target = makeSnapshot({
      threads: [
        {
          ...makeSnapshot().threads[0]!,
          messages: [
            {
              ...makeSnapshot().threads[0]!.messages[0]!,
              text: "Target-only conversation",
            },
          ],
          proposedPlans: [],
          activities: [],
        },
      ],
    });

    const archive = createPortabilityArchive(source, makeSettings(), NOW);

    const preview = previewPortabilityImport(
      archive,
      target,
      makeSettings(),
      AVAILABLE_PROVIDER_IDS,
    );

    expect(preview.conflicts).toContainEqual(
      expect.objectContaining({ recordType: "thread", id: THREAD_ID }),
    );
    expect(
      commandsForPortabilityImport(archive, target, makeSettings(), AVAILABLE_PROVIDER_IDS)
        .commands,
    ).not.toContainEqual(expect.objectContaining({ type: "thread.history.restore" }));
  });

  it("does not overwrite newer server settings", () => {
    const preview = previewPortabilityImport(
      createPortabilityArchive(makeSnapshot(), makeSettings(), NOW),
      makeSnapshot({ updatedAt: LATER }),
      DEFAULT_SERVER_SETTINGS,
      AVAILABLE_PROVIDER_IDS,
    );

    expect(preview.conflicts).toContainEqual({
      recordType: "server-settings",
      id: "server-settings",
      title: "Server settings",
    });
  });

  it("updates safe project fields only when the workspace reference matches", () => {
    const sourceProject = {
      ...makeSnapshot().projects[0]!,
      title: "Renamed portable project",
      defaultThreadEnvMode: "worktree" as const,
      updatedAt: LATER,
    };

    const source = makeSnapshot({ projects: [sourceProject], updatedAt: LATER });
    const archive = createPortabilityArchive(source, makeSettings(), LATER);
    const target = makeSnapshot();

    const preview = previewPortabilityImport(
      archive,
      target,
      makeSettings(),
      AVAILABLE_PROVIDER_IDS,
    );

    const plan = commandsForPortabilityImport(
      archive,
      target,
      makeSettings(),
      AVAILABLE_PROVIDER_IDS,
    );

    expect(preview.changes).toContainEqual(
      expect.objectContaining({ recordType: "project", id: PROJECT_ID }),
    );
    expect(plan.commands).toContainEqual({
      type: "project.meta.update",
      commandId: expect.any(String),
      projectId: PROJECT_ID,
      title: "Renamed portable project",
      defaultModelSelection: sourceProject.defaultModelSelection,
      defaultThreadEnvMode: "worktree",
    });
    expect(plan.commands).not.toContainEqual(
      expect.objectContaining({ type: "project.meta.update", workspaceRoot: expect.anything() }),
    );
  });

  it("maps projects and threads to a different target project ID by repository identity", () => {
    const targetProjectId = ProjectId.make("project-target");

    const sourceProject = {
      ...makeSnapshot().projects[0]!,
      title: "Renamed portable project",
      updatedAt: LATER,
    };

    const archive = createPortabilityArchive(
      makeSnapshot({ projects: [sourceProject], updatedAt: LATER }),
      makeSettings(),
      LATER,
    );

    const target = makeSnapshot({
      projects: [
        {
          ...makeSnapshot().projects[0]!,
          id: targetProjectId,
          title: "Local project",
          workspaceRoot: "/Volumes/code/private-clone",
        },
      ],
      threads: [],
    });

    const preview = previewPortabilityImport(
      archive,
      target,
      makeSettings(),
      AVAILABLE_PROVIDER_IDS,
    );

    const plan = commandsForPortabilityImport(
      archive,
      target,
      makeSettings(),
      AVAILABLE_PROVIDER_IDS,
    );

    expect(preview.changes).toContainEqual(
      expect.objectContaining({ recordType: "project", id: PROJECT_ID }),
    );
    expect(preview.additions).toContainEqual(
      expect.objectContaining({ recordType: "thread", id: THREAD_ID }),
    );
    expect(plan.commands).toContainEqual(
      expect.objectContaining({ type: "project.meta.update", projectId: targetProjectId }),
    );
    expect(plan.commands).toContainEqual(
      expect.objectContaining({ type: "thread.create", projectId: targetProjectId }),
    );
    expect(plan.commandItems).toContainEqual(
      expect.objectContaining({ recordType: "project", id: PROJECT_ID }),
    );
  });

  it("uses an unambiguous workspace name when repository identity is unavailable", () => {
    const targetProjectId = ProjectId.make("project-target");

    const source = makeSnapshot({
      projects: [{ ...makeSnapshot().projects[0]!, repositoryIdentity: null }],
    });

    const target = makeSnapshot({
      projects: [
        {
          ...makeSnapshot().projects[0]!,
          id: targetProjectId,
          workspaceRoot: "/Volumes/code/portable-project",
          repositoryIdentity: null,
        },
      ],
      threads: [],
    });

    const archive = createPortabilityArchive(source, makeSettings(), NOW);

    const plan = commandsForPortabilityImport(
      archive,
      target,
      makeSettings(),
      AVAILABLE_PROVIDER_IDS,
    );

    expect(plan.commands).toContainEqual(
      expect.objectContaining({ type: "thread.create", projectId: targetProjectId }),
    );
  });

  it("reports ambiguous project matches as conflicts", () => {
    const source = makeSnapshot();
    const baseProject = source.projects[0]!;

    const target = makeSnapshot({
      projects: [
        {
          ...baseProject,
          id: ProjectId.make("project-target-a"),
          workspaceRoot: "/Volumes/a/portable-project",
        },
        {
          ...baseProject,
          id: ProjectId.make("project-target-b"),
          workspaceRoot: "/Volumes/b/portable-project",
        },
      ],
      threads: [],
    });

    const archive = createPortabilityArchive(source, makeSettings(), NOW);

    const preview = previewPortabilityImport(
      archive,
      target,
      makeSettings(),
      AVAILABLE_PROVIDER_IDS,
    );

    const plan = commandsForPortabilityImport(
      archive,
      target,
      makeSettings(),
      AVAILABLE_PROVIDER_IDS,
    );

    expect(preview.conflicts).toEqual(
      expect.arrayContaining([
        expect.objectContaining({ recordType: "project", id: PROJECT_ID }),
        expect.objectContaining({ recordType: "thread", id: THREAD_ID }),
      ]),
    );
    expect(plan.commands.some((command) => command.type.startsWith("project."))).toBe(false);
    expect(plan.commands.some((command) => command.type.startsWith("thread."))).toBe(false);
  });

  it("rejects a stale preview token when projection state changes", () => {
    const snapshot = makeSnapshot();
    const settings = makeSettings();
    const archive = createPortabilityArchive(snapshot, settings, NOW);
    const preview = previewPortabilityImport(archive, snapshot, settings, AVAILABLE_PROVIDER_IDS);

    expect(isPortabilityPreviewCurrent(snapshot, settings, AVAILABLE_PROVIDER_IDS, preview)).toBe(
      true,
    );
    expect(
      isPortabilityPreviewCurrent(
        { ...snapshot, snapshotSequence: 8 },
        settings,
        AVAILABLE_PROVIDER_IDS,
        preview,
      ),
    ).toBe(false);
    expect(
      isPortabilityPreviewCurrent(
        snapshot,
        { ...settings, enableProviderUpdateChecks: !settings.enableProviderUpdateChecks },
        AVAILABLE_PROVIDER_IDS,
        preview,
      ),
    ).toBe(false);
    expect(isPortabilityPreviewCurrent(snapshot, settings, new Set(), preview)).toBe(false);
  });

  it("previews forced MCP disable as a change", () => {
    const snapshot = makeSnapshot();
    const settings = makeSettings();

    const preview = previewPortabilityImport(
      createPortabilityArchive(snapshot, settings, NOW),
      snapshot,
      settings,
      AVAILABLE_PROVIDER_IDS,
    );

    expect(preview.changes.map((entry) => entry.id)).toEqual([URL_MCP_ID, STDIO_MCP_ID]);
  });
});