Files
PaperClipAI/ui/src/pages/apps/chat/GitHubBotManagement.test.tsx
T
DottaandClaude Opus 5.5 b184e40108 perf(ui): serve every project list from one includeArchived read (#20395)
## Thinking Path

> - Paperclip is the open source app people use to manage AI agents for
work
> - The board UI reads the company project list in many places: the
sidebar, starred projects, the command palette, the new-task dialog, and
archive-aware pages such as the Mine inbox
> - Active-only consumers read `GET /projects`, and archive-aware ones
read `GET /projects?includeArchived=true`, under two React Query keys
> - A Mine load therefore fetched the same large payload twice (580–590
KB each on our dev instance)
> - The two responses differ only by archived rows; the server's active
list is exactly the rows where `archivedAt` is null
> - This pull request makes every consumer share the
`includeArchived=true` query, and active-only consumers filter it with
`select`
> - The benefit is one project read per page instead of two

## Linked Issues or Issue Description

**What existing behavior does this improve?**
Duplicate project list reads on page load.

**Subsystem affected**
Board UI project queries (`ui/src/lib/company-projects-query.ts` and its
consumers).

**Current behavior**
A cold Mine load sends both `/companies/:id/projects` (sidebar) and
`/companies/:id/projects?includeArchived=true` (inbox).

**Proposed behavior**
One `includeArchived=true` read serves both. Active-only consumers apply
`selectActiveProjects`.

**Reason and benefit**
The project list is one of the largest shell payloads. Reading it once
saves a large response on every page that has both kinds of consumer.

## What Changed

- New `companyProjectsQuery(companyId, { includeArchived? })` in
`ui/src/lib/company-projects-query.ts`. It always uses the
`includeArchived: true` key and fetch. For active-only use it adds a
stable, module-level `select` that keeps rows without `archivedAt`.
- 22 files that read the active list now spread
`companyProjectsQuery(...)`, and so do the plugin SDK project picker and
16 archive-aware pages that wrote the shared key and fetcher inline.
Their `enabled` and other options are unchanged. `OnboardingWizard`'s
one imperative read is unchanged. `pages/Inbox.tsx` already reads the
same key and fetcher, so it shares the entry without an edit.
- Invalidation: project mutations and live events invalidate
`queryKeys.projects.all(companyId)`, which matches the shared key. The
onboarding wizard invalidated the old active-only key; it now
invalidates `projects.all`.
- Tests: new `company-projects-query.test.tsx` (one request for both
consumers, correct filtering, and one refetch after `projects.all`
invalidation). Three existing tests (`CommandPalette`, `CompanyExport`,
`GitHubBotManagement`) now seed or expect the shared key.
- New browser check
`tests/perf/collections/shared-project-list.spec.ts`: after the Mine
inbox read completes, the page has sent no active-only project request.

## Verification

- `pnpm verify` passes.
- `ui`: the consumer suites (`CoordinatorSidebar`, `SidebarProjects`,
`SidebarStarredProjects`, `CommandPalette`, `NewIssueDialog`,
`AgentWorkPanels`, `CoordinatorNeedsYou`, `IssueDetail`,
`ProjectDetail`, `Projects`, `CompanyExport`, `ChatExecutionDefaults`,
`GatewaysList`, `Search`, `IssueProperties`, `persisted-query-cache`)
pass.
- Browser check:
`PAPERCLIP_COLLECTION_PERF_BASE_URL=http://127.0.0.1:<port> pnpm exec
playwright test --config tests/perf/collections/playwright.config.ts
shared-project-list.spec.ts`. It passes on this branch and fails on
`master`.

## Risks

- A page that needs only active projects now downloads archived rows
too. For most companies that is a small difference; the duplicate read
it removes is a full copy.
- The server does not order either list, and consumers sort for display,
so filtering on the client keeps behavior.

## Model Used

- Claude Opus 5.5 (`claude-opus-5-5`), Anthropic, via Claude Code with
tool use (shell, file edits, browser). 1M-token context window. Extended
thinking was off.

## Checklist

- [x] I have included a thinking path that traces from project context
to this change
- [x] I have specified the model used (with version and capability
details)
- [x] I have checked ROADMAP.md and confirmed this PR does not duplicate
planned core work
- [x] I have searched GitHub for duplicate or related PRs and linked
them above
- [x] I have either (a) linked existing issues with `Fixes: #` / `Closes
#` / `Refs #` OR (b) described the issue in-PR following the relevant
issue template
- [x] I have not referenced internal/instance-local Paperclip issues or
links (only public GitHub `#NNN` / `github.com/paperclipai/paperclip`
URLs)
- [x] My branch name describes the change (e.g. `docs/...`, `fix/...`)
and contains no internal Paperclip ticket id or instance-derived details
- [x] I have run tests locally and they pass
- [x] I have added or updated tests where applicable
- [x] I have updated relevant documentation to reflect my changes
- [x] I have considered and documented any risks above
- [ ] All Paperclip CI gates are green
- [ ] Greptile is 5/5 with no open P2s, recommendations, or follow-ups
- [x] I will address all Greptile and reviewer comments before
requesting merge

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-09 17:42:47 -06:00

853 lines
38 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// @vitest-environment jsdom
import { act } from "react";
import { createRoot, type Root } from "react-dom/client";
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import {
defaultGitHubReviewPolicy,
buildSkillMentionHref,
type GitHubChatConfiguration,
type GitHubTaskReview,
type ChatExecutionDefaults,
} from "@paperclipai/shared";
import { ApiError } from "@/api/client";
import { ChatEndpointDetail } from "./ChatEndpointDetail";
import { GitHubReviewList, orderedGitHubReviews } from "./GitHubBotManagement";
import { GitHubPolicyEditor } from "./GitHubBotConfiguration";
import { conversationDestination } from "./ChatConversationList";
import { queryKeys } from "@/lib/queryKeys";
import { TooltipProvider } from "@/components/ui/tooltip";
import { gitHubAppSettingsUrl, gitHubBotMention } from "./GitHubAppIdentity";
import type { ChatEndpoint } from "@/api/chatEndpoints";
const mocks = vi.hoisted(() => ({
tab: "settings",
reviewId: undefined as string | undefined,
get: vi.fn(),
config: vi.fn(),
save: vi.fn(),
resources: vi.fn(),
repositoryPage: vi.fn(),
toggleAll: vi.fn(),
updateResources: vi.fn(),
projects: vi.fn(),
workspaces: vi.fn(),
reviews: vi.fn(),
review: vi.fn(),
members: vi.fn(),
links: vi.fn(),
setBreadcrumbs: vi.fn(),
}));
vi.mock("@/api/githubChat", () => ({
githubChatApi: {
configuration: mocks.config,
save: mocks.save,
reviews: mocks.reviews,
review: mocks.review,
repositories: mocks.repositoryPage,
toggleAllRepositories: mocks.toggleAll,
},
}));
vi.mock("@/api/chatEndpoints", () => ({
chatEndpointsApi: {
get: mocks.get,
listResources: mocks.resources,
updateResources: mocks.updateResources,
listPrincipals: mocks.links,
},
}));
vi.mock("@/api/projects", () => ({ projectsApi: { list: mocks.projects } }));
vi.mock("@/api/execution-workspaces", () => ({ executionWorkspacesApi: { listSummaries: mocks.workspaces } }));
vi.mock("@/api/access", () => ({ accessApi: { listMembers: mocks.members } }));
vi.mock("@/api/agents", () => ({ agentsApi: { get: vi.fn() } }));
vi.mock("@/context/BreadcrumbContext", () => ({
useBreadcrumbs: () => ({ setBreadcrumbs: mocks.setBreadcrumbs }),
}));
vi.mock("@/context/CompanyContext", () => ({
useOptionalCompany: () => ({ companies: [{ id: "company", name: "Acme Research" }], selectedCompany: { id: "other", name: "Wrong company" } }),
}));
vi.mock("@/context/ToastContext", () => ({
useToast: () => ({ pushToast: vi.fn() }),
}));
vi.mock("@/components/MarkdownBody", () => ({
MarkdownBody: ({ children }: { children: React.ReactNode }) => (
<div>{children}</div>
),
}));
// Exercise settings persistence through the shared editor contract. The editor's
// rich rendering and slash picker have their own tests and a live walkthrough.
vi.mock("@/components/MarkdownEditor", () => ({
MarkdownEditor: ({ value, onChange, ariaLabel, placeholder, readOnly }: {
value: string; onChange: (value: string) => void; ariaLabel: string; placeholder?: string; readOnly?: boolean;
}) => <textarea aria-label={ariaLabel} placeholder={placeholder} value={value} readOnly={readOnly}
onChange={(event) => onChange(event.target.value)} />,
}));
vi.mock("@/lib/router", () => ({
useParams: () => ({
endpointId: "bot",
tab: mocks.tab,
reviewId: mocks.reviewId,
}),
useNavigate: () => vi.fn(),
useLocation: () => ({ state: null }),
Link: ({
children,
to,
...props
}: React.ComponentProps<"a"> & { to: string }) => (
<a href={to} {...props}>
{children}
</a>
),
Navigate: () => null,
}));
const endpoint = {
id: "bot",
companyId: "company",
provider: "github",
assignedAgentId: "agent",
assignedAgentName: "Maya",
status: "active",
allowUnlinkedPeople: false,
setup: { step: "complete" },
};
const base: GitHubChatConfiguration = {
version: 1,
toolsEnabled: true,
responsibleUserId: "member",
memberAccess: "selected",
people: [
{
kind: "member",
userId: "member",
githubUserId: "42",
login: "maya",
automaticReviews: true,
},
],
defaults: {
...defaultGitHubReviewPolicy(),
instructions: "Keep existing instructions",
issueOpened: true,
},
repositories: {},
};
describe("GitHub bot management", () => {
let root: Root;
let container: HTMLDivElement;
let client: QueryClient;
beforeEach(() => {
vi.clearAllMocks();
mocks.tab = "settings";
mocks.reviewId = undefined;
mocks.get.mockResolvedValue(endpoint);
mocks.projects.mockResolvedValue([]);
mocks.workspaces.mockResolvedValue([]);
mocks.config.mockResolvedValue({
revision: 4,
configuration: structuredClone(base),
});
mocks.resources.mockResolvedValue([
{
id: "repo",
type: "repository",
label: "acme/web",
enabled: true,
availability: "available",
metadata: { providerRepositoryId: "100" },
},
]);
mocks.repositoryPage.mockImplementation(async () => ({
items: await mocks.resources(), nextOffset: null, totalCount: 1, enabledCount: 1, availableCount: 1,
}));
mocks.toggleAll.mockResolvedValue({ success: true });
mocks.links.mockResolvedValue([
{
id: "link",
principalId: "identity",
status: "linked",
githubUserId: "42",
githubLogin: "maya",
paperclipUserId: "member",
paperclipUserLabel: "Maya",
},
]);
mocks.members.mockResolvedValue({
members: [
{
principalId: "member",
status: "active",
membershipRole: "owner",
user: { name: "Maya" },
},
],
});
mocks.reviews.mockResolvedValue([]);
mocks.save.mockImplementation(async (_id, revision, configuration) => ({
revision: revision + 1,
configuration,
}));
mocks.updateResources.mockResolvedValue([]);
client = new QueryClient({
defaultOptions: { queries: { retry: false, staleTime: Infinity } },
});
client.setQueryData(queryKeys.agents.detail("agent"), {
id: "agent",
name: "Maya",
});
container = document.createElement("div");
document.body.append(container);
root = createRoot(container);
});
afterEach(async () => {
await act(async () => root.unmount());
client.clear();
container.remove();
vi.unstubAllGlobals();
});
async function render(tab = mocks.tab) {
mocks.tab = tab;
await act(async () =>
root.render(
<QueryClientProvider client={client}>
<TooltipProvider>
<ChatEndpointDetail />
</TooltipProvider>
</QueryClientProvider>,
),
);
await vi.waitFor(() =>
expect(
container.querySelector(
'textarea[placeholder="What should this agent do on GitHub?"]',
) || container.querySelector('[aria-label="Allow mentions from all linked members"]'),
).not.toBeNull(),
);
}
async function click(name: string) {
const target = [...container.querySelectorAll("button")].find(
(b) =>
b.getAttribute("aria-label") === name || b.textContent?.trim() === name,
);
expect(target).toBeDefined();
await act(async () => target!.click());
}
async function input(
element: HTMLTextAreaElement | HTMLSelectElement | HTMLInputElement,
value: string,
) {
await act(async () => {
Object.getOwnPropertyDescriptor(
element instanceof HTMLTextAreaElement
? HTMLTextAreaElement.prototype
: element instanceof HTMLSelectElement ? HTMLSelectElement.prototype : HTMLInputElement.prototype,
"value",
)!.set!.call(element, value);
element.dispatchEvent(
new Event(element instanceof HTMLSelectElement ? "change" : "input", {
bubbles: true,
}),
);
});
}
it("loads repositories 20 at a time, searches all pages, and toggles the full connection", async () => {
let enabled = true;
const all = Array.from({ length: 1000 }, (_, index) => ({
id: `repo-${index}`, type: "repository", providerResourceId: `acme/repo-${index}`,
label: `acme/repo-${String(index).padStart(4, "0")}`, availability: "available", enabled: true,
}));
mocks.repositoryPage.mockImplementation(async (_id, { offset, search, limit }) => {
const filtered = all.filter((row) => row.label.includes(search));
return { items: filtered.slice(offset, offset + limit).map((row) => ({ ...row, enabled })),
nextOffset: offset + limit < filtered.length ? offset + limit : null,
totalCount: 1000, enabledCount: enabled ? 1000 : 0, availableCount: 1000 };
});
mocks.toggleAll.mockImplementation(async (_id, value) => { enabled = value; return { success: true }; });
await render("access");
await vi.waitFor(() => expect(container.querySelectorAll('[role="region"] [role="switch"]')).toHaveLength(20));
expect(mocks.repositoryPage).toHaveBeenCalledWith("bot", { offset: 0, limit: 20, search: "" });
await click("Load more repositories");
await vi.waitFor(() => expect(container.querySelectorAll('[role="region"] [role="switch"]')).toHaveLength(40));
const search = container.querySelector('input[aria-label="Search repositories"]') as HTMLInputElement;
await input(search, "0999");
await vi.waitFor(() => expect(container.querySelectorAll('[role="region"] [role="switch"]')).toHaveLength(1));
expect(container.textContent).toContain("acme/repo-0999");
expect(container.textContent).toContain("1000 of 1000 repositories enabled");
await click("Disable all repositories");
await vi.waitFor(() => expect(container.textContent).toContain("0 of 1000 repositories enabled"));
expect(mocks.toggleAll).toHaveBeenCalledWith("bot", false);
expect(mocks.updateResources).not.toHaveBeenCalled();
await click("Enable all repositories");
await vi.waitFor(() => expect(container.textContent).toContain("1000 of 1000 repositories enabled"));
expect(mocks.toggleAll).toHaveBeenLastCalledWith("bot", true);
await input(search, "does-not-exist");
await vi.waitFor(() => expect(container.textContent).toContain("No repositories match your search"));
expect(container.querySelector('button[aria-label="Disable all repositories"]')?.hasAttribute("disabled")).toBe(false);
});
it("keeps repository failures visible and allows a retry", async () => {
mocks.repositoryPage.mockRejectedValueOnce(new ApiError("Request failed: 500", 500, { error: "internal_error" }));
await render("access");
await vi.waitFor(() => expect(container.textContent).toContain("Couldn't load repositories"));
expect(container.textContent).not.toContain("internal_error");
await click("Retry");
await vi.waitFor(() => expect(container.querySelectorAll('[role="region"] [role="switch"]')).toHaveLength(1));
expect(container.textContent).not.toContain("Couldn't load repositories");
});
it("keeps loaded repositories on screen when a refetch fails transiently", async () => {
await render("access");
await vi.waitFor(() => expect(container.querySelectorAll('[role="region"] [role="switch"]')).toHaveLength(1));
mocks.repositoryPage.mockRejectedValue(new ApiError("Paperclip is restarting.", 503, { error: "tenant_app_unavailable" }));
await act(async () => {
await client.refetchQueries({ queryKey: ["github-bot-repository-pages", "bot"] });
});
expect(container.querySelectorAll('[role="region"] [role="switch"]')).toHaveLength(1);
expect(container.querySelector('[data-query-view="error"]')).toBeNull();
expect(container.textContent).not.toContain("Paperclip is restarting.");
expect(container.textContent).not.toContain("tenant_app_unavailable");
});
it("saves repository task defaults with explicit, cleared, and inherited values without changing access", async () => {
let executionDefaults: ChatExecutionDefaults | null = null;
mocks.projects.mockResolvedValue([{ id: "project", name: "Website", workspaces: [] }]);
mocks.workspaces.mockResolvedValue([{ id: "workspace", name: "Shared website" }]);
mocks.resources.mockImplementation(async () => [{
id: "repo", label: "acme/web", type: "repository", enabled: false,
availability: "available", executionDefaults,
}]);
mocks.updateResources.mockImplementation(async (_id, [update]) => {
executionDefaults = update.executionDefaults;
return mocks.resources();
});
await render("access");
await vi.waitFor(() => expect(container.querySelector('[role="region"] summary')).not.toBeNull());
await act(async () => (container.querySelector('[role="region"] summary') as HTMLElement).click());
const editor = container.querySelector('[role="region"] form')!;
const [project, workspace] = [...editor.querySelectorAll("select")];
await vi.waitFor(() => expect(workspace.disabled).toBe(false));
expect(mocks.projects).toHaveBeenCalledWith("company", { includeArchived: true });
expect(mocks.workspaces).toHaveBeenCalledWith("company", { selectableForTask: true });
expect(project.value).toBe("inherit");
expect(workspace.value).toBe("inherit");
expect(editor.textContent).toContain("Use connection defaults");
const save = async (expected: ChatExecutionDefaults | null) => {
const calls = mocks.updateResources.mock.calls.length;
await click("Save defaults");
await vi.waitFor(() => {
expect(mocks.updateResources).toHaveBeenCalledTimes(calls + 1);
expect(editor.textContent).toContain("Saved for new tasks.");
});
expect(mocks.updateResources).toHaveBeenLastCalledWith("bot", [{ id: "repo", executionDefaults: expected }]);
expect(container.querySelector('[role="region"] [role="switch"]')?.getAttribute("aria-checked")).toBe("false");
};
await input(project, "project");
await input(workspace, "existing:workspace");
await save({ projectId: "project", workspace: { kind: "existing", workspaceId: "workspace" } });
expect(project.value).toBe("project");
expect(workspace.value).toBe("existing:workspace");
await input(project, "none");
await input(workspace, "clear");
await save({ projectId: null, workspace: null });
await input(project, "inherit");
await save({ workspace: null });
await input(workspace, "inherit");
await save(null);
await vi.waitFor(() => {
expect(project.value).toBe("inherit");
expect(workspace.value).toBe("inherit");
});
expect(mocks.save).not.toHaveBeenCalled();
expect(mocks.toggleAll).not.toHaveBeenCalled();
});
it("keeps a rejected repository task-defaults draft visible for retry", async () => {
mocks.updateResources.mockRejectedValueOnce(new Error("Workspace access denied"));
await render("access");
await vi.waitFor(() => expect(container.querySelector('[role="region"] summary')).not.toBeNull());
await act(async () => (container.querySelector('[role="region"] summary') as HTMLElement).click());
const editor = container.querySelector('[role="region"] form')!;
const workspace = editor.querySelectorAll("select")[1];
await vi.waitFor(() => expect(workspace.disabled).toBe(false));
await input(workspace, "task");
await click("Save defaults");
await vi.waitFor(() => expect(editor.querySelector('[role="alert"]')?.textContent).toBe("Workspace access denied"));
expect(workspace.value).toBe("task");
expect(container.querySelector('[role="region"] [role="switch"]')?.getAttribute("aria-checked")).toBe("true");
await click("Cancel");
expect(workspace.value).toBe("inherit");
expect(editor.querySelector('[role="alert"]')).toBeNull();
});
it("stops automatic paging after a settled 429 while retaining rows and manual retry", async () => {
let intersect!: IntersectionObserverCallback;
let observers = 0;
vi.stubGlobal("IntersectionObserver", class {
constructor(callback: IntersectionObserverCallback) { intersect = callback; observers += 1; }
observe() {}
disconnect() {}
});
let failed = true;
mocks.repositoryPage.mockImplementation(async (_id, { offset }) => {
if (offset && failed) throw new ApiError("Throttled", 429, null, { retryAfterMs: 60_000 });
return { items: Array.from({ length: 20 }, (_, index) => ({ id: `repo-${offset + index}`, label: `sample/repo-${offset + index}`, enabled: true, availability: "available", type: "repository" })),
nextOffset: offset === 0 ? 20 : null, totalCount: 40, enabledCount: 40, availableCount: 40 };
});
await render("access");
await vi.waitFor(() => expect(intersect).toBeDefined());
const initialObservers = observers;
await act(async () => intersect([{ isIntersecting: true } as IntersectionObserverEntry], {} as IntersectionObserver));
await vi.waitFor(() => expect(client.getQueryState(["github-bot-repository-pages", "bot", ""])?.status).toBe("error"));
await act(async () => { await Promise.resolve(); });
expect(observers).toBe(initialObservers);
expect(mocks.repositoryPage).toHaveBeenCalledTimes(2);
expect(container.querySelectorAll('[role="region"] [role="switch"]')).toHaveLength(20);
failed = false;
await click("Load more repositories");
await vi.waitFor(() => expect(container.querySelectorAll('[role="region"] [role="switch"]')).toHaveLength(40));
expect(mocks.repositoryPage).toHaveBeenCalledTimes(3);
});
it("automatically loads the next 20 repositories when the scroll sentinel becomes visible", async () => {
let intersect!: IntersectionObserverCallback;
vi.stubGlobal("IntersectionObserver", class {
constructor(callback: IntersectionObserverCallback) { intersect = callback; }
observe() {}
disconnect() {}
});
mocks.repositoryPage.mockImplementation(async (_id, { offset }) => ({
items: Array.from({ length: 20 }, (_, index) => ({
id: `repo-${offset + index}`, label: `acme/repo-${offset + index}`,
enabled: true, availability: "available", type: "repository",
})),
nextOffset: offset === 0 ? 20 : null, totalCount: 40, enabledCount: 40, availableCount: 40,
}));
await render("access");
await vi.waitFor(() => expect(intersect).toBeDefined());
await act(async () => intersect([{ isIntersecting: true } as IntersectionObserverEntry], {} as IntersectionObserver));
await vi.waitFor(() => expect(container.querySelectorAll('[role="region"] [role="switch"]')).toHaveLength(40));
expect(mocks.repositoryPage).toHaveBeenLastCalledWith("bot", { offset: 20, limit: 20, search: "" });
});
it("shows the verified custom App mention and its own organization branding settings", async () => {
const branded: ChatEndpoint = {
...endpoint,
provider: "github",
status: "active",
botLabel: "Maya Reviews",
botUsername: "maya-reviews[bot]",
providerAccountLabel: "acme",
setup: {
step: "complete",
github: {
stage: "verify",
appOwnerType: "organization",
appOwnerLogin: "acme",
appSlug: "old-draft-name",
},
},
};
mocks.get.mockResolvedValue(branded);
await render();
expect(
container.querySelector('button[aria-label="Copy GitHub mention"]')
?.textContent,
).toBe("@maya-reviews");
expect(container.textContent).toContain("Maya Reviews");
const branding = [...container.querySelectorAll("a")].find((a) =>
a.getAttribute("aria-label") === "Edit App name and logo on GitHub",
);
expect(branding?.href).toBe(
"https://github.com/organizations/acme/settings/apps/maya-reviews",
);
expect(
container.querySelector("a[download]")?.getAttribute("download"),
).toBe("Maya-Reviews-avatar.png");
expect(mocks.save).not.toHaveBeenCalled();
expect(
gitHubAppSettingsUrl({
...branded,
setup: {
step: "complete",
github: { stage: "verify", appOwnerType: "personal" },
},
}),
).toBe("https://github.com/settings/apps/maya-reviews");
expect(
gitHubAppSettingsUrl({ ...branded, setup: { step: "complete" } }),
).toBe("https://github.com/settings/apps");
expect(gitHubBotMention({ botUsername: null })).toBeNull();
});
it("keeps one draft across Settings, Access, and read-only tabs, then saves with the original revision", async () => {
await render();
await input(container.querySelector("textarea")!, "Edited instructions");
await render("access");
await click("Allow mentions from all linked members");
await render("reviews");
await render("settings");
expect(container.querySelector("textarea")?.value).toBe(
"Edited instructions",
);
expect(mocks.save).not.toHaveBeenCalled();
await click("Save changes");
await vi.waitFor(() => expect(mocks.save).toHaveBeenCalledTimes(1));
const [id, revision, saved] = mocks.save.mock.calls[0];
expect(id).toBe("bot");
expect(revision).toBe(4);
expect(saved).toEqual({
...base,
defaults: { ...base.defaults, instructions: "Edited instructions" },
memberAccess: "all_linked",
});
await vi.waitFor(() =>
expect(container.textContent).toContain("Changes saved."),
);
expect(
[...container.querySelectorAll("button")].some(
(b) => b.textContent === "Save changes",
),
).toBe(false);
});
it("retains a rejected draft and lets the user discard it", async () => {
mocks.save.mockRejectedValue(
new Error("Configuration changed. Reload before saving."),
);
await render();
await input(container.querySelector("textarea")!, "Unsaved");
await click("Save changes");
await vi.waitFor(() =>
expect(container.querySelector('[role="alert"]')?.textContent).toContain(
"Configuration changed",
),
);
expect(container.querySelector("textarea")?.value).toBe("Unsaved");
await click("Discard changes");
expect(container.querySelector("textarea")?.value).toBe(
base.defaults.instructions,
);
expect(container.querySelector('[role="alert"]')).toBeNull();
});
it("saves repository restrictions separately without touching the behavior draft", async () => {
await render();
await input(container.querySelector("textarea")!, "Unsaved behavior");
await render("access");
await vi.waitFor(() => expect(container.querySelector('button[aria-label="acme/web"]')).not.toBeNull());
await click("acme/web");
await vi.waitFor(() =>
expect(mocks.updateResources).toHaveBeenCalledWith("bot", [
{ id: "repo", enabled: false },
]),
);
expect(mocks.save).not.toHaveBeenCalled();
await render("settings");
expect(container.querySelector("textarea")?.value).toBe("Unsaved behavior");
});
it("hides repository overrides while preserving saved overrides when other settings change", async () => {
const overrides = { "100": { instructions: "Retain repository guidance", events: ["opened"] } };
mocks.config.mockResolvedValue({
revision: 4,
configuration: { ...base, repositories: overrides },
});
await render();
expect(container.textContent).not.toContain("Repository overrides");
expect(container.querySelector("#github-policy-repository")).toBeNull();
expect(mocks.resources).not.toHaveBeenCalled();
await input(container.querySelector("textarea")!, "Updated default instructions");
await click("Save changes");
await vi.waitFor(() => expect(mocks.save).toHaveBeenCalled());
const saved = mocks.save.mock.calls[0][2];
expect(saved.defaults.instructions).toBe("Updated default instructions");
expect(saved.repositories).toEqual(overrides);
});
it("names the endpoint company and omits per-person automatic switches", async () => {
mocks.config.mockResolvedValue({ revision: 4, configuration: { ...base, memberAccess: "all_linked", people: [] } });
await render("access");
await vi.waitFor(() => expect(container.textContent).toContain("@maya"));
expect(container.textContent).toContain("Includes members from Acme Research who link their GitHub account later.");
expect(container.textContent).not.toContain("Wrong company");
expect(container.querySelector('[aria-label="Run automatically for @maya"]')).toBeNull();
await click("Allow mentions from all linked members");
await click("Allow mentions from @maya");
await click("Save changes");
expect(mocks.save.mock.calls[0][2].people).toEqual([{ kind: "member", userId: "member", githubUserId: "42", login: "maya" }]);
});
it("does not show an off switch or silently enable a retained disabled bot", async () => {
mocks.config.mockResolvedValue({
revision: 4,
configuration: { ...base, toolsEnabled: false },
});
await render("access");
expect(
container.querySelector('[aria-label="Use this bot’s GitHub tools"]'),
).toBeNull();
expect(container.textContent).toContain("cannot start work or respond");
await render("settings");
await input(container.querySelector("textarea")!, "Edited instructions");
await click("Save changes");
await vi.waitFor(() => expect(mocks.save).toHaveBeenCalled());
expect(mocks.save.mock.calls[0][2].toolsEnabled).toBe(false);
});
it("loads a direct review URL and keeps unknown reviews within the current connection", async () => {
mocks.reviewId = "review-1";
mocks.reviews.mockResolvedValue([]);
mocks.review.mockImplementation(async (_endpoint, id) => {
if (id !== "review-1") throw new ApiError("Review not found", 404, { error: "Review not found" });
return review("review-1", "repo", 1, "2026-10-07T10:00:00Z");
});
await render("reviews");
await vi.waitFor(() =>
expect(container.textContent).toContain(
"No assessment has been submitted yet.",
),
);
expect(
container.querySelector('a[href="/apps/chat/bot/reviews"]')?.textContent,
).toContain("All reviews");
mocks.reviewId = "foreign";
await render("reviews");
await vi.waitFor(() =>
expect(container.textContent).toContain("not found in this connection"),
);
expect(container.textContent).not.toContain(
"No assessment has been submitted yet.",
);
});
it("keeps saved automatic triggers when changing to mentions-only", async () => {
const change = vi.fn();
await act(async () =>
root.render(
<TooltipProvider>
<GitHubPolicyEditor policy={base.defaults} onChange={change} />
</TooltipProvider>,
),
);
await click("Run automatically");
expect(change.mock.calls[0][0]).toEqual({
...base.defaults,
invocation: "mentions_only",
});
});
it("keeps external-author mode and event choices when automatic runs are switched off and back on", async () => {
mocks.config.mockResolvedValue({ revision: 4, configuration: { ...base, defaults: { ...base.defaults, invocation: "allowed_authors" } } });
await render();
await click("Run automatically");
await click("Run automatically");
expect(container.querySelector('[aria-label="Save changes"]')).toBeNull();
await input(container.querySelector("textarea")!, "Still keep the same audience");
await click("Save changes");
expect(mocks.save.mock.calls[0][2].defaults).toEqual({ ...base.defaults, invocation: "allowed_authors", instructions: "Still keep the same audience" });
});
it("preserves an invalid score across Access and Settings without saving a stale value", async () => {
await render();
await input(container.querySelector('input[type="number"]')!, "6");
await render("access");
expect([...container.querySelectorAll("button")].find(b => b.textContent === "Save changes")?.disabled).toBe(true);
await render("settings");
expect(container.querySelector<HTMLInputElement>('input[type="number"]')!.value).toBe("6");
await click("Discard changes");
expect(container.querySelector<HTMLInputElement>('input[type="number"]')!.value).toBe("5");
expect(mocks.save).not.toHaveBeenCalled();
});
it("remembers external-author automation across tab changes", async () => {
mocks.config.mockResolvedValue({ revision: 4, configuration: { ...base, defaults: { ...base.defaults, invocation: "allowed_authors" } } });
await render(); await click("Run automatically");
await render("access"); await render("settings"); await click("Run automatically");
await input(container.querySelector("textarea")!, "Updated");
await click("Save changes");
expect(mocks.save.mock.calls[0][2].defaults.invocation).toBe("allowed_authors");
});
it("makes common and event instruction editors read-only throughout a pending save", async () => {
let finish!: (value: unknown) => void;
mocks.save.mockImplementation(() => new Promise(resolve => { finish = resolve; }));
await render();
await input(container.querySelector("textarea")!, "Saved instructions");
await act(async () => [...container.querySelectorAll("summary")].find(s => s.textContent?.includes("Event-specific instructions"))!.click());
await click("Save changes");
expect([...container.querySelectorAll<HTMLTextAreaElement>("textarea[aria-label]")].every(editor => editor.readOnly)).toBe(true);
await act(async () => { finish({ revision: 5, configuration: { ...base, defaults: { ...base.defaults, instructions: "Saved instructions" } } }); });
expect(container.querySelector("textarea")!.readOnly).toBe(false);
});
it("defaults to a typed score of 5 and preserves report-only and other review decisions", async () => {
await render();
const score = container.querySelector<HTMLInputElement>('input[type="number"]')!;
expect(score.value).toBe("5");
expect(container.querySelector('input[type="range"]')).toBeNull();
await input(score, "3");
await click("Save changes");
expect(mocks.save.mock.calls[0][2].defaults).toEqual({ ...base.defaults, ratingThreshold: 3 });
await click("Report only");
await click("Save changes");
expect(mocks.save.mock.calls[1][2].defaults.ratingThreshold).toBeNull();
expect(score.disabled).toBe(true);
await click("Report only");
expect(score.value).toBe("5");
});
it.each(["", "0", "6", "2.5"])("does not save an invalid score %s and allows correction or discard", async (value) => {
await render();
const score = container.querySelector<HTMLInputElement>('input[type="number"]')!;
await input(score, value);
expect(container.textContent).toContain("Enter a whole number from 1 to 5.");
await click("Save changes");
expect(mocks.save).not.toHaveBeenCalled();
await input(score, "4");
await click("Save changes");
expect(mocks.save.mock.calls[0][2].defaults.ratingThreshold).toBe(4);
await input(score, value);
await click("Discard changes");
expect(container.querySelector<HTMLInputElement>('input[type="number"]')?.value).toBe("4");
expect(container.querySelector('[role="alert"]')).toBeNull();
});
it("retains a saved report-only policy until the user changes it", async () => {
mocks.config.mockResolvedValue({ revision: 4, configuration: { ...base, defaults: { ...base.defaults, ratingThreshold: null } } });
await render();
expect(container.querySelector<HTMLInputElement>('input[type="number"]')?.disabled).toBe(true);
await input(container.querySelector("textarea")!, "Updated guidance");
await click("Save changes");
expect(mocks.save.mock.calls[0][2].defaults.ratingThreshold).toBeNull();
});
it("turns off selected member access without retaining an authorization entry", async () => {
await render("access");
await vi.waitFor(() => expect(container.querySelector('[aria-label="Allow mentions from @maya"]')?.hasAttribute("disabled")).toBe(false));
await click("Allow mentions from @maya");
expect(container.querySelector('[aria-label="Run automatically for @maya"]')).toBeNull();
await click("Save changes");
expect(mocks.save.mock.calls[0][2].people).toEqual([]);
expect(mocks.save.mock.calls[0][2].memberAccess).toBe("selected");
});
it("keeps automatic runs off when editing member access", async () => {
mocks.config.mockResolvedValue({ revision: 4, configuration: { ...base, defaults: { ...base.defaults, invocation: "mentions_only" } } });
await render("access");
await click("Allow mentions from all linked members");
await click("Save changes");
expect(mocks.save.mock.calls[0][2].defaults.invocation).toBe("mentions_only");
});
it("keeps newlines and commas while editing filters, saves separate entries, and restores discarded values", async () => {
await render();
const paths = container.querySelector<HTMLTextAreaElement>('textarea[id$="github-ignoredPaths"]')!;
await input(paths, "dist/**\n");
expect(paths.value).toBe("dist/**\n");
await input(paths, `${paths.value}vendor/**`);
const categories = container.querySelector<HTMLInputElement>('input[id$="github-categories"]')!;
await input(categories, "security, ");
expect(categories.value).toBe("security, ");
await input(categories, `${categories.value}correctness`);
await click("Save changes");
expect(mocks.save.mock.calls[0][2].defaults.ignoredPaths).toEqual(["dist/**", "vendor/**"]);
expect(mocks.save.mock.calls[0][2].defaults.findingCategories).toEqual(["security", "correctness"]);
await input(paths, "tmp/**");
await click("Discard changes");
expect(container.querySelector<HTMLTextAreaElement>('textarea[id$="github-ignoredPaths"]')?.value).toBe("dist/**\nvendor/**");
});
it("saves skill links in general and event instructions without resetting other guidance", async () => {
await render();
const skill = `[/review](${buildSkillMentionHref("11111111-1111-4111-8111-111111111111", "review")})`;
await input(container.querySelector('textarea[aria-label="Agent instructions"]')!, `Use ${skill}.`);
await input(container.querySelector('select[id$="github-prompt-event"]')!, "mention");
await input(container.querySelector('textarea[aria-label="Mention instructions"]')!, `For mentions, use ${skill}.`);
await input(container.querySelector('select[id$="github-prompt-event"]')!, "issue_opened");
await input(container.querySelector('textarea[aria-label="New issue instructions"]')!, `For issues, use ${skill}.`);
await click("Save changes");
const saved = mocks.save.mock.calls[0][2];
expect(saved.defaults.instructions).toBe(`Use ${skill}.`);
expect(saved.defaults.prompts.mention).toBe(`For mentions, use ${skill}.`);
expect(saved.defaults.issueOpenedInstructions).toBe(`For issues, use ${skill}.`);
expect(saved.defaults.prompts.opened).toBe(base.defaults.prompts.opened);
expect(saved.people).toEqual(base.people);
});
it.each(["mentions_only", "linked_authors", "allowed_authors"] as const)(
"makes mentions explicit in the selected %s mode", async (invocation) => {
await act(async () => root.render(<TooltipProvider>
<GitHubPolicyEditor policy={{ ...base.defaults, invocation }} onChange={() => {}} />
</TooltipProvider>));
expect(container.querySelector('[aria-label="Run automatically"]')?.getAttribute("aria-checked")).toBe(String(invocation !== "mentions_only"));
expect(container.textContent).toContain("Authorized people can always @mention this bot.");
},
);
});
function review(
id: string,
repositoryId: string,
pullNumber: number,
createdAt: string,
updatedAt = createdAt,
) {
return {
id,
repositoryId,
pullNumber,
createdAt,
updatedAt,
repository: "acme/web",
headSha: id,
issueId: "task",
event: { title: "Review focus handling" },
state: "queued",
assessment: null,
conclusion: null,
} as GitHubTaskReview;
}
describe("review history and thread labels", () => {
it("keeps every review in creation order, independent of late updates to an older head", () => {
const old = review(
"old",
"repo",
1,
"2026-10-07T10:00:00Z",
"2026-10-07T14:00:00Z",
);
const current = review("current", "repo", 1, "2026-10-07T11:00:00Z");
const other = review("other", "another-repo", 1, "2026-10-07T12:00:00Z");
expect(orderedGitHubReviews([old, current, other])).toEqual([
other,
current,
old,
]);
});
it("does not present a previous passing score as the pending current commit’s result", async () => {
const old = review("old", "repo", 1, "2026-10-07T10:00:00Z");
old.state = "completed";
old.conclusion = "success";
old.assessment = {
reviewedCommit: "old",
score: 5,
complete: true,
summary: "Previous result",
rationale: "Complete",
findings: [],
coverage: { reviewedPaths: [], omittedPaths: [], limitations: [] },
};
const current = review("current", "repo", 1, "2026-10-07T11:00:00Z");
const container = document.createElement("div");
const root = createRoot(container);
try {
await act(async () =>
root.render(
<GitHubReviewList endpointId="bot" reviews={[old, current]} />,
),
);
const rows = [...container.querySelectorAll("li")];
expect(rows).toHaveLength(2);
expect(rows[0].textContent).toContain("Queued");
expect(rows[0].textContent).not.toContain("5/5");
expect(rows[0].querySelector("a")?.getAttribute("href")).toBe(
"/apps/chat/bot/reviews/current",
);
expect(rows[1].textContent).toContain("5/5 · Passed");
expect(rows[1].querySelector("a")?.getAttribute("href")).toBe(
"/apps/chat/bot/reviews/old",
);
expect(container.querySelector("details")).toBeNull();
} finally {
await act(async () => root.unmount());
}
});
it("identifies GitHub thread numbers while preserving labels for other providers and invalid URLs", () => {
const row = {
externalLabel: "acme/web",
externalUrl: "https://github.com/acme/web/issues/42#issuecomment-1",
} as any;
expect(conversationDestination(row, "github")).toBe("acme/web #42");
expect(conversationDestination(row, "slack")).toBe("acme/web");
expect(
conversationDestination({ ...row, externalUrl: "invalid" }, "github"),
).toBe("acme/web");
});
});