@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 04:45 UTC

main
tsx 830 lines 31.2 KB
Raw
1 import { RegistryContext } from "@effect/atom-react";
2 import type {
3 DeleteProjectInput,
4 UpdateProjectInput,
5 } from "@t3tools/client-runtime/state/projects";
6 import {
7 AuthOrchestrationOperateScope,
8 AuthSettingsWriteScope,
9 DEFAULT_SERVER_SETTINGS,
10 EnvironmentId,
11 ProjectId,
12 ProviderInstanceId,
13 type AuthEnvironmentScope,
14 type AuthSessionState,
15 } from "@t3tools/contracts";
16 import { DEFAULT_CLIENT_SETTINGS } from "@t3tools/contracts/settings";
17 import { DEFAULT_RESOLVED_KEYBINDINGS } from "@t3tools/shared/keybindings";
18 import {
19 createMemoryHistory,
20 createRootRoute,
21 createRoute,
22 createRouter,
23 RouterProvider,
24 } from "@tanstack/react-router";
25 import * as Cause from "effect/Cause";
26 import { AsyncResult, Atom } from "effect/reactivity";
27 import { describe, expect, it, vi } from "vite-plus/test";
28 import { page, userEvent } from "vite-plus/test/browser";
29
30 import { act, render, type Screen } from "../../../test/render";
31 import type { Project } from "../../types";
32
33 type SessionResult = AsyncResult.AsyncResult<AuthSessionState, Error>;
34 const state = vi.hoisted(() => ({
35 sessions: new Map<EnvironmentId, Atom.Writable<SessionResult>>(),
36 projects: [] as Project[],
37 update:
38 vi.fn<
39 (request: {
40 environmentId: EnvironmentId;
41 input: UpdateProjectInput;
42 }) => Promise<AsyncResult.Success<void> | AsyncResult.Failure<void, Error>>
43 >(),
44 delete:
45 vi.fn<
46 (request: {
47 environmentId: EnvironmentId;
48 input: DeleteProjectInput;
49 }) => Promise<AsyncResult.Success<void>>
50 >(),
51 confirm: vi.fn<() => Promise<boolean>>(),
52 releaseUploads: vi.fn(),
53 clearDraft: vi.fn(),
54 toast: vi.fn(),
55 }));
56
57 // Session grants come from the server; each test drives them through these atoms.
58 vi.mock(import("@t3tools/client-runtime/state/session"), async (original) => {
59 const actual = await original();
60 return {
61 ...actual,
62 createEnvironmentSessionAtoms: ((
63 ...args: Parameters<typeof actual.createEnvironmentSessionAtoms>
64 ) => ({
65 ...actual.createEnvironmentSessionAtoms(...args),
66 sessionStateAtom: (id: EnvironmentId) => state.sessions.get(id)!,
67 })) as typeof actual.createEnvironmentSessionAtoms,
68 };
69 });
70 vi.mock(import("~/state/environments"), async (original) => ({
71 ...(await original()),
72 useEnvironments: (() => ({ environments })) as never,
73 readEnvironment: ((id: EnvironmentId) =>
74 environments.find((environment) => environment.environmentId === id) ?? null) as never,
75 usePrimaryEnvironmentId: () => primaryId,
76 }));
77 vi.mock(import("~/state/entities"), async (original) => ({
78 ...(await original()),
79 useProjects: (() => state.projects) as never,
80 useThreadShells: () => [],
81 useServerConfigs: (() =>
82 new Map(
83 environments.map((environment) => [environment.environmentId, environment.serverConfig]),
84 )) as never,
85 waitForProjectRemoval: async () => true,
86 }));
87 vi.mock(import("~/state/projects"), async (original) => {
88 const actual = await original();
89 return {
90 ...actual,
91 projectEnvironment: {
92 ...actual.projectEnvironment,
93 update: "update",
94 delete: "delete",
95 } as unknown as typeof actual.projectEnvironment,
96 };
97 });
98 vi.mock(import("~/state/use-atom-command"), async (original) => ({
99 ...(await original()),
100 useAtomCommand: ((command: "update" | "delete") => state[command]) as never,
101 }));
102 vi.mock(import("~/hooks/useSettings"), async (original) => ({
103 ...(await original()),
104 useClientSettings: ((selector?: (settings: typeof DEFAULT_CLIENT_SETTINGS) => unknown) =>
105 selector ? selector(DEFAULT_CLIENT_SETTINGS) : DEFAULT_CLIENT_SETTINGS) as never,
106 }));
107 vi.mock(import("~/localApi"), async (original) => ({
108 ...(await original()),
109 readLocalApi: (() => ({ dialogs: { confirm: state.confirm } })) as never,
110 }));
111 vi.mock(import("~/lib/composerDraftUploads"), async (original) => ({
112 ...(await original()),
113 releaseProjectDraftUploads: state.releaseUploads,
114 }));
115 // No toaster is mounted in these tests; the guard's error toast is read at this seam.
116 vi.mock(import("../ui/toast"), async (original) => {
117 const actual = await original();
118 return { ...actual, toastManager: { ...actual.toastManager, add: state.toast } };
119 });
120 // These sections have separate data sources and their own tests.
121 vi.mock(import("./ProjectDefaultsSettings"), async (original) => ({
122 ...(await original()),
123 ProjectDefaultsSettings: (() => null) as never,
124 }));
125 vi.mock(import("./ProjectActionsSettings"), async (original) => ({
126 ...(await original()),
127 ProjectActionsSettings: (() => null) as never,
128 }));
129
130 vi.mock(import("../files/projectFilesQueryState"), async (original) => ({
131 ...(await original()),
132 getProjectFileQueryAtom: () => missingProjectFile,
133 }));
134
135 import { scopeProjectRef } from "@t3tools/client-runtime/environment";
136 import { DraftId, useComposerDraftStore } from "../../composerDraftStore";
137 import { appAtomRegistry } from "../../rpc/atomRegistry";
138 import { assetEnvironment } from "../../state/assets";
139 import { buildSidebarProjectSnapshots } from "../../sidebarProjectGrouping";
140 import { ProjectSettingsPanel } from "./ProjectSettingsPanel";
141 import { ProjectsSettings } from "./ProjectsSettings";
142 import { SettingsScopeProvider } from "./SettingsScopeContext";
143 import { SettingsScopeNotice } from "./SettingsScopeNotice";
144 import { validateSettingsScopeSearch, type SettingsScopeSearch } from "./settingsScope";
145 import { retainSettingsScope, validateSettingsRouteSearch } from "./settingsScopeNavigation";
146
147 const primaryId = EnvironmentId.make("primary");
148 const remoteId = EnvironmentId.make("remote");
149 const instanceId = ProviderInstanceId.make("codex");
150 const environments = [primaryId, remoteId].map((environmentId) => ({
151 environmentId,
152 label: environmentId,
153 connection: { phase: "connected" },
154 serverConfig: {
155 keybindings: DEFAULT_RESOLVED_KEYBINDINGS,
156 settings: DEFAULT_SERVER_SETTINGS,
157 environment: { platform: { machine: "server" }, capabilities: { projectOrganization: true } },
158 },
159 }));
160 const session = (scopes: ReadonlyArray<AuthEnvironmentScope>): AuthSessionState => ({
161 authenticated: true,
162 scopes,
163 auth: {
164 policy: "remote-reachable",
165 bootstrapMethods: ["one-time-token"],
166 sessionMethods: ["bearer-access-token"],
167 sessionCookieName: "t3_session",
168 },
169 });
170 const writable = () => AsyncResult.success(session([AuthOrchestrationOperateScope]));
171 const missingProjectFile = Atom.make(AsyncResult.initial<never, never>());
172
173 function deferred<T>() {
174 let resolve!: (value: T) => void;
175 const promise = new Promise<T>((complete) => {
176 resolve = complete;
177 });
178 return { promise, resolve };
179 }
180
181 function setup() {
182 vi.clearAllMocks();
183 state.sessions.clear();
184 for (const id of [primaryId, remoteId])
185 state.sessions.set(id, Atom.make<SessionResult>(writable()).pipe(Atom.keepAlive));
186 state.projects = [primaryId, remoteId].map((environmentId) => ({
187 id: ProjectId.make(`project-${environmentId}`),
188 environmentId,
189 title: "Shared repo",
190 workspaceRoot: `/work/${environmentId}`,
191 repositoryIdentity: {
192 canonicalKey: "github.com/example/shared-repo",
193 locator: {
194 source: "git-remote",
195 remoteName: "origin",
196 remoteUrl: "https://github.com/example/shared-repo.git",
197 },
198 },
199 defaultModelSelection: { instanceId, model: "gpt-5-codex" },
200 createdAt: "2026-01-01T00:00:00.000Z",
201 updatedAt: "2026-01-01T00:00:00.000Z",
202 scripts: [],
203 }));
204 state.update.mockImplementation(async ({ environmentId, input }) => {
205 const { projectId, ...updates } = input;
206 const patch = Object.fromEntries(
207 Object.entries(updates).filter(([, value]) => value !== undefined),
208 ) as Partial<Project>;
209 state.projects = state.projects.map((project) =>
210 project.environmentId === environmentId && project.id === projectId
211 ? { ...project, ...patch }
212 : project,
213 );
214 return AsyncResult.success(undefined);
215 });
216 state.delete.mockResolvedValue(AsyncResult.success(undefined));
217 state.confirm.mockResolvedValue(true);
218 useComposerDraftStore.setState({ clearProjectDraftThreadId: state.clearDraft });
219 }
220
221 function projectKey() {
222 return buildSidebarProjectSnapshots({
223 projects: state.projects,
224 settings: DEFAULT_CLIENT_SETTINGS,
225 primaryEnvironmentId: primaryId,
226 resolveEnvironmentLabel: (id) => id,
227 })[0]!.projectKey;
228 }
229
230 async function mountPanel(search: Omit<SettingsScopeSearch, "project"> = {}) {
231 const key = projectKey();
232 const rootRoute = createRootRoute();
233 const settingsRoute = createRoute({
234 getParentRoute: () => rootRoute,
235 path: "settings",
236 validateSearch: validateSettingsRouteSearch,
237 search: { middlewares: [retainSettingsScope] },
238 });
239 const projectsRoute = createRoute({
240 getParentRoute: () => settingsRoute,
241 path: "projects",
242 component: () => (
243 <ProjectSettingsPanel
244 projectKey={key}
245 environmentId={search.machine ? EnvironmentId.make(search.machine) : null}
246 checkoutKey={search.checkout ?? null}
247 />
248 ),
249 });
250 const query = new URLSearchParams({ project: key });
251 for (const [name, value] of Object.entries(search)) {
252 if (value !== undefined) query.set(name, value);
253 }
254 const router = createRouter({
255 routeTree: rootRoute.addChildren([settingsRoute.addChildren([projectsRoute])]),
256 history: createMemoryHistory({ initialEntries: [`/settings/projects?${query}`] }),
257 });
258 await router.load();
259 await using stack = new AsyncDisposableStack();
260 const screen = stack.use(
261 // The panel's own route tree validates settings search params, which the default router lacks.
262 await render(
263 <RegistryContext.Provider value={appAtomRegistry}>
264 <RouterProvider router={router} />
265 </RegistryContext.Provider>,
266 { router: false },
267 ),
268 );
269 await vi.waitFor(() => expect(nameInput(screen)).not.toBeNull());
270 stack.move();
271 return { ...screen, router };
272 }
273
274 async function mountSettings(search: SettingsScopeSearch) {
275 const searchParams = new URLSearchParams(
276 Object.entries(search).flatMap(([key, value]) => (value === undefined ? [] : [[key, value]])),
277 );
278 const route = createRootRoute({
279 validateSearch: validateSettingsScopeSearch,
280 component: () => (
281 <SettingsScopeProvider
282 search={route.useSearch()}
283 onChange={(next) => void router.navigate({ to: "/settings/projects", search: () => next })}
284 >
285 <ProjectsSettings />
286 </SettingsScopeProvider>
287 ),
288 });
289 const router = createRouter({
290 routeTree: route,
291 history: createMemoryHistory({
292 initialEntries: [`/settings/projects?${searchParams.toString()}`],
293 }),
294 });
295 await router.load();
296 // The settings route tree above validates scope search params, which the default router lacks.
297 const screen = await render(
298 <RegistryContext.Provider value={appAtomRegistry}>
299 <RouterProvider router={router} />
300 </RegistryContext.Provider>,
301 { router: false },
302 );
303 return { ...screen, router };
304 }
305
306 const nameInput = (screen: Screen) =>
307 screen.container.querySelector<HTMLInputElement>('[aria-label="Project name"]')!;
308 const removeCheckout = (screen: Screen, root: string) =>
309 screen.container.querySelector<HTMLButtonElement>(`[aria-label="Remove checkout ${root}"]`)!;
310 const removeAll = (screen: Screen) =>
311 [...screen.container.querySelectorAll("button")].find((button) =>
312 button.textContent?.includes("Remove all entries"),
313 )!;
314
315 async function grant(id: EnvironmentId, result: SessionResult) {
316 await act(async () => appAtomRegistry.set(state.sessions.get(id)!, result));
317 }
318
319 async function rename(screen: Screen, title: string) {
320 await userEvent.fill(nameInput(screen), title);
321 await userEvent.keyboard("{Enter}");
322 }
323
324 // The recheck reports the denial by toast; seeing it proves the recheck ran.
325 async function expectProjectAccessDeniedToast(title: string) {
326 await vi.waitFor(() =>
327 expect(state.toast).toHaveBeenCalledWith(
328 expect.objectContaining({
329 type: "error",
330 title,
331 description: "This connection cannot change projects in remote.",
332 }),
333 ),
334 );
335 expect(state.toast).toHaveBeenCalledOnce();
336 }
337
338 describe("project organization", () => {
339 it("archives the checkout on every machine while one machine is picked", async () => {
340 setup();
341 await using _screen = await mountPanel({ machine: primaryId });
342 await userEvent.click(page.getByRole("button", { name: "Archive" }));
343 await vi.waitFor(() => expect(state.update).toHaveBeenCalledTimes(2));
344 expect(
345 state.update.mock.calls.map(([request]) => [request.environmentId, request.input.archived]),
346 ).toEqual([
347 [primaryId, true],
348 [remoteId, true],
349 ]);
350 });
351 });
352
353 describe("project settings permissions", () => {
354 it("disables shared edits when any member lacks project access", async () => {
355 setup();
356 await grant(remoteId, AsyncResult.success(session([AuthSettingsWriteScope])));
357 await using screen = await mountPanel();
358
359 expect(nameInput(screen).disabled).toBe(true);
360 expect(removeAll(screen).disabled).toBe(true);
361 expect(screen.container.textContent).toContain(
362 "Shared settings require permission to change every checkout in this group.",
363 );
364 expect(state.update).not.toHaveBeenCalled();
365 });
366
367 it("renames every member when all have project access without settings access", async () => {
368 setup();
369 await using screen = await mountPanel();
370 await rename(screen, "Renamed");
371 expect(state.update.mock.calls.map(([request]) => request.environmentId)).toEqual([
372 primaryId,
373 remoteId,
374 ]);
375 expect(nameInput(screen).value).toBe("Renamed");
376 });
377
378 it("stops before the next member if its grant is revoked during an earlier update", async () => {
379 setup();
380 const firstUpdate = deferred<AsyncResult.Success<void>>();
381 state.update.mockReturnValueOnce(firstUpdate.promise);
382 await using screen = await mountPanel();
383 await rename(screen, "Renamed");
384 expect(state.update).toHaveBeenCalledOnce();
385
386 await grant(remoteId, AsyncResult.success(session([])));
387 await act(async () => {
388 firstUpdate.resolve(AsyncResult.success(undefined));
389 await firstUpdate.promise;
390 });
391 await expectProjectAccessDeniedToast("Failed to rename project");
392 expect(state.update).toHaveBeenCalledOnce();
393 expect(state.update.mock.calls[0]![0].environmentId).toBe(primaryId);
394 });
395
396 it("disables removal for a checkout whose project grant is missing", async () => {
397 setup();
398 await grant(remoteId, AsyncResult.success(session([])));
399 await using screen = await mountPanel();
400 expect(removeCheckout(screen, "/work/remote").disabled).toBe(true);
401 expect(removeCheckout(screen, "/work/primary").disabled).toBe(false);
402 });
403
404 it("removes a writable checkout while removal of the mixed group stays denied", async () => {
405 setup();
406 await grant(remoteId, AsyncResult.success(session([])));
407 await using screen = await mountPanel();
408 const initialHref = screen.router.state.location.href;
409 expect(removeAll(screen).disabled).toBe(true);
410
411 await userEvent.click(removeCheckout(screen, "/work/primary"));
412 await vi.waitFor(() => expect(state.delete).toHaveBeenCalledOnce());
413 expect(state.delete).toHaveBeenCalledWith({
414 environmentId: primaryId,
415 input: { projectId: state.projects[0]!.id, force: true },
416 });
417 await vi.waitFor(() => expect(state.releaseUploads).toHaveBeenCalledOnce());
418 expect(state.clearDraft).toHaveBeenCalledOnce();
419 expect(screen.router.state.location.href).toBe(initialHref);
420 });
421
422 it("moves a draft on the removed checkout to a remaining checkout of the group", async () => {
423 setup();
424 const draftId = DraftId.make("draft-handed-off");
425 const [primaryProject, remoteProject] = state.projects;
426 const drafts = useComposerDraftStore.getState();
427 drafts.setLogicalProjectDraftThreadId(
428 "github.com/example/shared-repo",
429 scopeProjectRef(primaryId, primaryProject!.id),
430 draftId,
431 );
432 // "Add to another machine" hands the open draft to the new checkout this way.
433 drafts.setDraftThreadContext(draftId, {
434 projectRef: scopeProjectRef(remoteId, remoteProject!.id),
435 environmentSelection: "manual",
436 loadBalancedEnvironmentId: null,
437 });
438 drafts.setPrompt(draftId, "keep this prompt");
439 await using screen = await mountPanel();
440
441 await userEvent.click(removeCheckout(screen, "/work/remote"));
442 await vi.waitFor(() => expect(state.releaseUploads).toHaveBeenCalledOnce());
443
444 expect(useComposerDraftStore.getState().getDraftSession(draftId)).toMatchObject({
445 environmentId: primaryId,
446 projectId: primaryProject!.id,
447 });
448 expect(useComposerDraftStore.getState().getComposerDraft(draftId)?.prompt).toBe(
449 "keep this prompt",
450 );
451 });
452
453 it("rechecks every removal target after confirmation before deleting or clearing drafts", async () => {
454 setup();
455 const confirmed = deferred<boolean>();
456 state.confirm.mockReturnValueOnce(confirmed.promise);
457 await using screen = await mountPanel();
458 await userEvent.click(removeAll(screen));
459 expect(state.confirm).toHaveBeenCalledOnce();
460
461 await grant(remoteId, AsyncResult.success(session([])));
462 await act(async () => {
463 confirmed.resolve(true);
464 await confirmed.promise;
465 });
466 await expectProjectAccessDeniedToast("Failed to remove project");
467 expect(state.delete).not.toHaveBeenCalled();
468 expect(state.releaseUploads).not.toHaveBeenCalled();
469 expect(state.clearDraft).not.toHaveBeenCalled();
470 });
471
472 it("does not save an edit whose grant was revoked mid-edit, and recovers when restored", async () => {
473 setup();
474 await using screen = await mountPanel();
475 await userEvent.fill(nameInput(screen), "Renamed");
476 await grant(remoteId, AsyncResult.success(session([])));
477 // Chromium takes focus off a newly disabled input without firing blur. Send the
478 // focusout so the save attempt runs and hits the same recheck as a real blur.
479 await act(async () => {
480 nameInput(screen).dispatchEvent(new FocusEvent("focusout", { bubbles: true }));
481 });
482 await expectProjectAccessDeniedToast("Failed to rename project");
483 expect(state.update).not.toHaveBeenCalled();
484 expect(nameInput(screen).disabled).toBe(true);
485
486 await grant(remoteId, writable());
487 expect(nameInput(screen).disabled).toBe(false);
488 await rename(screen, "Recovered");
489 await vi.waitFor(() => expect(state.update).toHaveBeenCalledTimes(2));
490 expect(nameInput(screen).value).toBe("Recovered");
491 });
492
493 it.each([
494 ["loading", () => AsyncResult.initial<AuthSessionState, Error>(), false],
495 [
496 "failed",
497 () => AsyncResult.failure<AuthSessionState, Error>(Cause.fail(new Error("Disconnected"))),
498 false,
499 ],
500 ["refreshing", () => AsyncResult.waiting(writable()), true],
501 ] as const)(
502 "uses the current grant while a member's session is %s",
503 async (_state, result, allowed) => {
504 setup();
505 await grant(remoteId, result());
506 await using screen = await mountPanel();
507 expect(nameInput(screen).disabled).toBe(!allowed);
508 if (!allowed) return;
509 await rename(screen, "Renamed");
510 expect(state.update).toHaveBeenCalledTimes(2);
511 },
512 );
513 });
514
515 describe("project identity reset", () => {
516 const scratchIcon = { kind: "lucide", name: "message-square-dashed", color: "gray" } as const;
517 const resetButton = (screen: Screen, label: string) =>
518 screen.container.querySelector<HTMLButtonElement>(`[aria-label="Reset ${label} to default"]`);
519 const asScratch = (project: Project): Project => ({
520 ...project,
521 isScratch: true,
522 title: "Notes",
523 workspaceRoot: "/t3/scratch",
524 projectIcon: { kind: "emoji", emoji: "📝" },
525 });
526
527 it("restores a renamed scratch project's built-in name and icon", async () => {
528 setup();
529 state.projects = [{ ...asScratch(state.projects[0]!), faviconPath: null, projectIcon: null }];
530 await using screen = await mountPanel();
531
532 await userEvent.click(resetButton(screen, "project name")!);
533 await vi.waitFor(() =>
534 expect(state.update).toHaveBeenCalledWith({
535 environmentId: primaryId,
536 input: { projectId: state.projects[0]!.id, title: "No project" },
537 }),
538 );
539 await userEvent.click(resetButton(screen, "project icon")!);
540 await vi.waitFor(() =>
541 expect(state.update).toHaveBeenLastCalledWith({
542 environmentId: primaryId,
543 input: { projectId: state.projects[0]!.id, faviconPath: null, projectIcon: scratchIcon },
544 }),
545 );
546 });
547
548 it("resets each member of a mixed group to its own default icon", async () => {
549 setup();
550 const [primary, remote] = state.projects;
551 state.projects = [asScratch(primary!), { ...remote!, faviconPath: "logo.png" }];
552 await using screen = await mountPanel();
553
554 expect(resetButton(screen, "project name")).toBeNull();
555 await userEvent.click(resetButton(screen, "project icon")!);
556 await vi.waitFor(() => expect(state.update).toHaveBeenCalledTimes(2));
557 expect(state.update.mock.calls.map(([request]) => request)).toEqual([
558 {
559 environmentId: primaryId,
560 input: { projectId: primary!.id, faviconPath: null, projectIcon: scratchIcon },
561 },
562 {
563 environmentId: remoteId,
564 input: { projectId: remote!.id, faviconPath: null, projectIcon: null },
565 },
566 ]);
567 });
568
569 it("refreshes a saved checkout's icon when a later checkout update fails", async () => {
570 setup();
571 state.projects = state.projects.map((project) => ({ ...project, faviconPath: "logo.png" }));
572 let iconExists = false;
573 const iconUrl = Atom.make(() =>
574 AsyncResult.success({
575 expiresAt: 4_000_000_000_000,
576 relativeUrl: iconExists ? "/restored-icon.svg" : "/project-favicon-missing",
577 }),
578 );
579 using _mount = { [Symbol.dispose]: appAtomRegistry.mount(iconUrl) };
580 const createUrl = assetEnvironment.createUrl;
581 using _createUrl = vi
582 .spyOn(assetEnvironment, "createUrl")
583 .mockImplementation((target) =>
584 target.environmentId === primaryId ? iconUrl : createUrl(target),
585 );
586 state.update
587 .mockResolvedValueOnce(AsyncResult.success(undefined))
588 .mockResolvedValueOnce(AsyncResult.failure(Cause.fail(new Error("Save failed"))));
589 await using screen = await mountPanel();
590 expect(appAtomRegistry.get(iconUrl).value.relativeUrl).toBe("/project-favicon-missing");
591
592 iconExists = true;
593 await userEvent.click(resetButton(screen, "project icon")!);
594
595 await vi.waitFor(() =>
596 expect(appAtomRegistry.get(iconUrl).value.relativeUrl).toBe("/restored-icon.svg"),
597 );
598 expect(state.toast).toHaveBeenCalledWith(
599 expect.objectContaining({ title: "Failed to update project icon on remote" }),
600 );
601 });
602 });
603
604 it("opens the fallback search target across all environments from a checkout", async () => {
605 setup();
606 const root = createRootRoute();
607 const settings = createRoute({
608 getParentRoute: () => root,
609 path: "settings",
610 validateSearch: validateSettingsRouteSearch,
611 search: { middlewares: [retainSettingsScope] },
612 });
613 const threads = createRoute({
614 getParentRoute: () => settings,
615 path: "threads",
616 component: () => (
617 <SettingsScopeProvider search={settings.useSearch()} onChange={() => {}}>
618 <SettingsScopeNotice target="all" targetId="fallback-model">
619 Choose all environments to edit the fallback model.
620 </SettingsScopeNotice>
621 </SettingsScopeProvider>
622 ),
623 });
624 const query = new URLSearchParams({
625 project: projectKey(),
626 machine: primaryId,
627 checkout: "primary:/work/primary",
628 });
629 const router = createRouter({
630 routeTree: root.addChildren([settings.addChildren([threads])]),
631 history: createMemoryHistory({ initialEntries: [`/settings/threads?${query}#fallback-model`] }),
632 });
633 await router.load();
634 // This route needs the real scope-retention middleware used by settings search.
635 await using _screen = await render(
636 <RegistryContext.Provider value={appAtomRegistry}>
637 <RouterProvider router={router} />
638 </RegistryContext.Provider>,
639 { router: false },
640 );
641 await userEvent.click(page.getByRole("button", { name: "Open all environments" }));
642 await vi.waitFor(() => expect(router.state.location.search).toEqual({}));
643 expect(router.state.location.hash).toBe("fallback-model");
644 });
645
646 describe("project settings scope", () => {
647 const environmentMenu = () => page.getByRole("button", { name: /^Environment scope:/ });
648 const primaryOption = () => page.getByRole("menuitemradio", { name: /^primary/ });
649 const remoteOption = () => page.getByRole("menuitemradio", { name: /^remote/ });
650
651 it("offers every environment while no project is selected", async () => {
652 setup();
653 state.projects = state.projects.filter((project) => project.environmentId === primaryId);
654 await using _screen = await mountSettings({});
655
656 await userEvent.click(environmentMenu());
657 await expect.element(primaryOption()).toBeVisible();
658 await expect.element(remoteOption()).toBeVisible();
659 });
660
661 it("lists only the selected environment's projects and keeps it when one is opened", async () => {
662 setup();
663 const [primaryProject, remoteProject] = state.projects;
664 state.projects = [
665 primaryProject!,
666 {
667 ...remoteProject!,
668 title: "Remote only",
669 repositoryIdentity: null,
670 },
671 ];
672 await using screen = await mountSettings({ machine: primaryId });
673
674 await expect.element(page.getByRole("button", { name: /^Shared repo/ })).toBeVisible();
675 await expect
676 .element(page.getByRole("button", { name: /^Remote only/ }))
677 .not.toBeInTheDocument();
678
679 await userEvent.click(page.getByRole("button", { name: /^Shared repo/ }));
680 await vi.waitFor(() =>
681 expect(screen.router.state.location.search).toEqual({
682 project: projectKey(),
683 machine: primaryId,
684 }),
685 );
686 });
687
688 it("offers only the selected project's checkout environments", async () => {
689 setup();
690 state.projects = state.projects.filter((project) => project.environmentId === primaryId);
691 await using _screen = await mountSettings({ project: projectKey() });
692
693 await expect.element(page.getByRole("textbox", { name: "Project name" })).toBeVisible();
694 await userEvent.click(environmentMenu());
695 await expect.element(primaryOption()).toBeVisible();
696 await expect.element(remoteOption()).not.toBeInTheDocument();
697 });
698
699 it("reaches each checkout on one environment and returns to all of them", async () => {
700 setup();
701 const [first] = state.projects;
702 state.projects = [
703 { ...first!, id: ProjectId.make("clone-a"), workspaceRoot: "/work/clone-a" },
704 { ...first!, id: ProjectId.make("clone-b"), workspaceRoot: "/work/clone-b" },
705 ];
706 const key = projectKey();
707 await using screen = await mountSettings({ project: key, machine: primaryId });
708
709 await userEvent.click(page.getByRole("button", { name: "Checkout scope: All checkouts" }));
710 await userEvent.click(page.getByRole("menuitemradio", { name: /clone-b/ }));
711
712 await expect
713 .element(page.getByRole("button", { name: "Checkout scope: clone-b" }))
714 .toBeVisible();
715 expect(screen.router.state.location.search).toMatchObject({
716 project: key,
717 machine: primaryId,
718 checkout: expect.stringContaining("clone-b"),
719 });
720
721 await userEvent.click(page.getByRole("button", { name: "Checkout scope: clone-b" }));
722 await userEvent.click(page.getByRole("menuitemradio", { name: "All checkouts" }));
723
724 await vi.waitFor(() =>
725 expect(screen.router.state.location.search).toEqual({ project: key, machine: primaryId }),
726 );
727 });
728
729 it("keeps an unknown project recoverable from any environment", async () => {
730 setup();
731 state.projects = state.projects.filter((project) => project.environmentId === primaryId);
732 await using screen = await mountSettings({ project: "removed-project" });
733
734 await userEvent.click(environmentMenu());
735 await expect.element(primaryOption()).toBeVisible();
736 await expect.element(remoteOption()).toBeVisible();
737 await userEvent.click(remoteOption());
738 await vi.waitFor(() =>
739 expect(screen.router.state.location.search).toEqual({
740 project: "removed-project",
741 machine: remoteId,
742 }),
743 );
744 });
745
746 it.each([
747 [undefined, "This project has no checkout on this environment."],
748 [
749 "removed-checkout",
750 "This checkout is no longer available in the selected project and environment.",
751 ],
752 ])("recovers a stale environment link with checkout %s", async (checkout, message) => {
753 setup();
754 state.projects = state.projects.filter((project) => project.environmentId === primaryId);
755 const key = projectKey();
756 await using screen = await mountSettings({
757 project: key,
758 machine: remoteId,
759 ...(checkout ? { checkout } : {}),
760 });
761
762 await expect.element(page.getByText(message, { exact: true })).toBeVisible();
763 await expect.element(page.getByRole("button", { name: /^Project scope:/ })).toBeVisible();
764 await expect
765 .element(page.getByRole("button", { name: "Environment scope: remote" }))
766 .toBeVisible();
767 await userEvent.click(page.getByRole("button", { name: "Show all environments" }));
768
769 await expect
770 .element(page.getByRole("textbox", { name: "Project name" }))
771 .toHaveValue("Shared repo");
772 expect(screen.router.state.location.search).toEqual({ project: key });
773 await expect
774 .element(page.getByRole("button", { name: "Environment scope: All environments" }))
775 .toBeVisible();
776 await expect.element(page.getByText(message, { exact: true })).not.toBeInTheDocument();
777 await expect
778 .element(page.getByRole("button", { name: "Remove project", exact: true }))
779 .toBeEnabled();
780 });
781 });
782
783 it("returns to the project overview after removal, clearing the selection but keeping the environment", async () => {
784 setup();
785 state.projects = [state.projects[1]!];
786 await using screen = await mountPanel({ machine: remoteId, checkout: "remote:/work/remote" });
787 const removeProject = [...screen.container.querySelectorAll("button")].find(
788 (button) => button.textContent === "Remove project",
789 )!;
790
791 await userEvent.click(removeProject);
792
793 await vi.waitFor(() => {
794 expect(screen.router.state.location.pathname).toBe("/settings/projects");
795 expect(screen.router.state.location.search).toEqual({ machine: remoteId });
796 });
797 });
798
799 describe("project name composition", () => {
800 it.each([
801 { isComposing: true, keyCode: 13 },
802 { isComposing: false, keyCode: 229 },
803 ])("does not save a partial name for $isComposing/$keyCode", async (composition) => {
804 setup();
805 await using screen = await mountPanel();
806 const input = nameInput(screen);
807 await userEvent.fill(input, "日本");
808 await act(async () => {
809 input.dispatchEvent(
810 new KeyboardEvent("keydown", { key: "Enter", bubbles: true, ...composition }),
811 );
812 });
813 expect(state.update).not.toHaveBeenCalled();
814 await expect.element(input).toHaveFocus();
815
816 await userEvent.type(input, "語");
817 await userEvent.keyboard("{Enter}");
818 await vi.waitFor(() => expect(state.update).toHaveBeenCalledTimes(2));
819 expect(state.projects.map((project) => project.title)).toEqual(["日本語", "日本語"]);
820 await expect.element(nameInput(screen)).toHaveValue("日本語");
821
822 await userEvent.fill(nameInput(screen), "日本語の名前");
823 await userEvent.keyboard("{Tab}");
824 await vi.waitFor(() => expect(state.update).toHaveBeenCalledTimes(4));
825 expect(state.projects.map((project) => project.title)).toEqual([
826 "日本語の名前",
827 "日本語の名前",
828 ]);
829 });
830 });