The best way to control Claude Code, Codex and more from any computer or phone
| 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 | }); |