sailfork / t3code-github / apps/ web/ src/ components/ settings/ AcpSessionManagementSection.browser.test.tsx

import {
  EnvironmentId,
  ProjectId,
  ProviderDriverKind,
  ProviderInstanceId,
  ThreadId,
  type ServerProvider,
  type AcpRegistryConfigurableProvider,
} from "@t3tools/contracts";
import { expect, it, vi } from "vite-plus/test";
import { userEvent } from "vite-plus/test/browser";

import { act, render } from "../../../test/render";

const commands = vi.hoisted(() => ({
  list: vi.fn(),
  import: vi.fn(),
  delete: vi.fn(),
  listProviders: vi.fn(),
  setProvider: vi.fn(),
  disableProvider: vi.fn(),
  logout: vi.fn(),
}));
const grants = vi.hoisted(() => ({ scopes: new Set<string>() }));
const dialogs = vi.hoisted(() => ({ confirm: vi.fn() }));

vi.mock(import("~/state/session"), async (original) => ({
  ...(await original()),
  useEnvironmentScope: ((_id: unknown, scope: string) => grants.scopes.has(scope)) as never,
  readEnvironmentScope: ((_id: unknown, scope: string) => grants.scopes.has(scope)) as never,
}));
vi.mock(import("../../state/use-atom-command"), async (original) => {
  const { serverEnvironment } = await import("../../state/server");
  const byAtom = new Map<unknown, unknown>([
    [serverEnvironment.listAcpRegistrySessions, commands.list],
    [serverEnvironment.importAcpRegistrySession, commands.import],
    [serverEnvironment.deleteAcpRegistrySession, commands.delete],
    [serverEnvironment.listAcpRegistryProviders, commands.listProviders],
    [serverEnvironment.setAcpRegistryProvider, commands.setProvider],
    [serverEnvironment.disableAcpRegistryProvider, commands.disableProvider],
    [serverEnvironment.logoutAcpRegistry, commands.logout],
  ]);
  return {
    ...(await original()),
    useAtomCommand: ((atom: unknown) => byAtom.get(atom)) as never,
  };
});
vi.mock(import("../../localApi"), async (original) => ({
  ...(await original()),
  ensureLocalApi: () => ({ dialogs }) as never,
}));

import { AcpSessionManagementSection } from "./AcpSessionManagementSection";

const environmentId = EnvironmentId.make("remote-device");
const instanceId = ProviderInstanceId.make("acpRegistry_antigravity");
const projectId = ProjectId.make("project-antigravity");
const session = {
  sessionId: "native-session-1",
  cwd: "/workspace/antigravity",
  additionalDirectories: [],
  title: "Native Antigravity session",
  updatedAt: "2026-08-23T00:00:00Z",
  importedThreadId: null,
} as const;
const provider = {
  instanceId,
  driver: ProviderDriverKind.make("acpRegistry"),
  enabled: true,
  installed: true,
  version: "1.0.0",
  status: "ready",
  auth: { status: "authenticated", canLogout: true },
  nativeSessions: { canList: true, canLoad: true, canResume: true, canDelete: true },
  configurableProviders: true,
  checkedAt: "2026-08-23T00:00:00.000Z",
  models: [],
  slashCommands: [],
  skills: [],
} satisfies ServerProvider;

async function renderSection(readOnly = false) {
  const screen = await render(
    <AcpSessionManagementSection
      environmentId={environmentId}
      instanceId={instanceId}
      provider={provider}
      projects={[{ id: projectId, title: "Antigravity", workspaceRoot: session.cwd }]}
      readOnly={readOnly}
    />,
  );
  const button = (label: string) => {
    const found = [...screen.container.querySelectorAll("button")].find(
      (element) => element.textContent === label,
    );
    expect(found, `button ${label}`).toBeDefined();
    return found!;
  };
  return Object.assign(screen, {
    button,
    click: (label: string) => act(async () => button(label).click()),
  });
}

function setup() {
  grants.scopes = new Set(["orchestration:read", "orchestration:operate", "providers:manage"]);
  commands.list.mockReset().mockResolvedValue({
    _tag: "Success",
    value: {
      sessions: [session],
      nextCursor: null,
      canLoad: true,
      canResume: true,
      canDelete: true,
    },
  });
  commands.import.mockReset().mockResolvedValue({
    _tag: "Success",
    value: { threadId: ThreadId.make("thread-imported"), imported: true },
  });
  commands.delete.mockReset().mockResolvedValue({
    _tag: "Success",
    value: { deleted: true },
  });
  commands.listProviders.mockReset().mockResolvedValue({
    _tag: "Success",
    value: {
      providers: [
        {
          providerId: "google",
          supported: ["openai"],
          required: false,
          current: { apiType: "openai", baseUrl: "https://api.example.test/v1" },
        },
      ],
    },
  });
  commands.setProvider.mockReset().mockResolvedValue({
    _tag: "Success",
    value: { configured: true },
  });
  commands.disableProvider.mockReset().mockResolvedValue({
    _tag: "Success",
    value: { disabled: true },
  });
  commands.logout.mockReset().mockResolvedValue({
    _tag: "Success",
    value: { loggedOut: true },
  });
  dialogs.confirm.mockReset().mockResolvedValue(true);
}

it("does not import with provider management alone", async () => {
  setup();
  grants.scopes.delete("orchestration:operate");
  await using screen = await renderSection();
  await screen.click("List sessions");
  expect(screen.button("Import").disabled).toBe(true);
  await screen.click("Import");
  expect(commands.import).not.toHaveBeenCalled();
});

it("rechecks task access after confirming deletion", async () => {
  setup();
  await using screen = await renderSection();
  await screen.click("List sessions");
  dialogs.confirm.mockImplementationOnce(async () => {
    grants.scopes.delete("orchestration:operate");
    return true;
  });
  await screen.click("Delete");
  expect(commands.delete).not.toHaveBeenCalled();
});

it.each(["Save", "Disable"])("keeps other provider edits through a %s refetch", async (action) => {
  setup();
  const providers: AcpRegistryConfigurableProvider[] = ["google", "other"].map((providerId) => ({
    providerId,
    supported: ["openai"],
    required: false,
    current: { apiType: "openai", baseUrl: "https://api.example.test/v1" },
  }));
  const response = { _tag: "Success" as const, value: { providers } };
  commands.listProviders.mockResolvedValue(response);
  await using screen = await renderSection();
  await screen.click("List providers");
  const input = (label: string) =>
    screen.container.querySelector<HTMLInputElement>(`[aria-label="${label}"]`)!;
  await userEvent.fill(input("other base URL"), "https://other.example.test/v1");
  await userEvent.fill(input("other write-only headers JSON"), '{"X-Test":"unsaved"}');
  await userEvent.fill(input("google write-only headers JSON"), '{"X-Test":"saved"}');

  let resolveReload!: (value: typeof response) => void;
  const reload = new Promise<typeof response>((resolve) => {
    resolveReload = resolve;
  });
  commands.listProviders.mockReturnValueOnce(reload);
  let resolveMutation!: () => void;
  const mutation = new Promise<void>((resolve) => {
    resolveMutation = resolve;
  });
  const command = action === "Save" ? commands.setProvider : commands.disableProvider;
  command.mockReturnValueOnce(
    mutation.then(() => ({
      _tag: "Success",
      value: action === "Save" ? { configured: true } : { disabled: true },
    })),
  );
  await screen.click(action);
  expect(screen.button("Refresh").disabled).toBe(true);
  await act(async () => resolveMutation());
  for (const button of screen.container.querySelectorAll<HTMLButtonElement>("button")) {
    if (button.textContent === "Save" || button.textContent === "Disable") {
      expect(button.disabled).toBe(true);
    }
  }
  await userEvent.fill(input("other base URL"), "https://newer.example.test/v1");
  await act(async () => resolveReload(response));

  expect(input("other base URL").value).toBe("https://newer.example.test/v1");
  expect(input("other write-only headers JSON").value).toBe('{"X-Test":"unsaved"}');
  expect(input("google write-only headers JSON").value).toBe("");
  await screen.click("Refresh");
  expect(input("other base URL").value).toBe("https://api.example.test/v1");
  expect(input("other write-only headers JSON").value).toBe("");
});