Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
Keep organization access bound to the selected read
pulse-triage[bot]4fb2457c5e85
diff --git a/frontend-modern/browser-verification/18a1e997e94a0284.json b/frontend-modern/browser-verification/18a1e997e94a0284.jsonnew file mode 100644index 0000000000..4174bbe30f--- /dev/null+++ b/frontend-modern/browser-verification/18a1e997e94a0284.json@@ -0,0 +1,76 @@+{+ "version": 1,+ "base_sha": "b0923554fcc531166f1e5c3500c7a1b94cf06931",+ "verified_at": "2026-10-31T17:41:47.863Z",+ "result": "passed",+ "changed_paths": [+ "frontend-modern/src/api/orgs.ts",+ "frontend-modern/src/components/Settings/OrganizationAccessInvitationsSection.tsx",+ "frontend-modern/src/components/Settings/OrganizationAccessManagementSection.tsx",+ "frontend-modern/src/components/Settings/OrganizationAccessPanel.tsx",+ "frontend-modern/src/components/Settings/useOrganizationAccessPanelState.ts",+ "frontend-modern/src/utils/organizationSettingsPresentation.ts"+ ],+ "content_sha256": {+ "frontend-modern/src/api/orgs.ts": "57345a09f2fe818ec50ad435ede99ff823f075e0c77896d091306e9b56126c7e",+ "frontend-modern/src/components/Settings/OrganizationAccessInvitationsSection.tsx": "0a8b5c32e45272b7c00616fd4d86fd8c008531eb8d0e372e79a7ac3c621b49b2",+ "frontend-modern/src/components/Settings/OrganizationAccessManagementSection.tsx": "94ef2a2924d3f6608985afff5a364af92008ec239a51cfb03c9b45b2598478aa",+ "frontend-modern/src/components/Settings/OrganizationAccessPanel.tsx": "8c6a2bc014cefbe68aecdf0afcd725f16be520bf9fa9d01f0ed385ed83d6bc0c",+ "frontend-modern/src/components/Settings/useOrganizationAccessPanelState.ts": "aeeddfa26d44270f048896b61ccbd58945957755b3d53f9e73c52e9067d69f6b",+ "frontend-modern/src/utils/organizationSettingsPresentation.ts": "f1a8a7a0c80786c0c873fc40de7b761b4bc9d5e432efe9cdf62b7dd4db47ddf5"+ },+ "routes": [+ "Existing Organization Access settings: production panel, state, API client and stylesheet served in an isolated HTTP fixture"+ ],+ "viewports": [+ {+ "width": 1440,+ "height": 1050+ },+ {+ "width": 320,+ "height": 900+ }+ ],+ "states": [+ "Selected organization unavailable, not empty",+ "Pending read-only reload",+ "Successful selected-org read and cleared peer draft",+ "Unconfirmed mutation requires read reconciliation",+ "Accepted empty membership",+ "Read-only session with disabled invitation controls",+ "Late prior-org read ignored",+ "Interrupted mutation cannot affect a different selection"+ ],+ "interactions": [+ "Switch organization during failed and delayed reads; retry only the selected read",+ "Deliberately invite a member, change their role, revoke an invitation and confirm member removal on the current organization",+ "As a viewer, accept and decline only the loaded personal invitation without member-management controls",+ "Refuse a POST with 403: no transport replay; reload preserves the draft before a deliberate second change",+ "Switch while POST is pending: no mutation replay, stale toast, new-draft loss or stale selection replacement",+ "Lose and restore the existing multi-tenant capability; fresh selected read, no old save replay",+ "Select default explicitly, retaining exact default read identity"+ ],+ "browsers": [+ {+ "engine": "Chromium",+ "version": "141.0.7390.37"+ },+ {+ "engine": "WebKit",+ "version": "26.0"+ }+ ],+ "playwright_version": "1.56.1",+ "checks": 74,+ "captures": 16,+ "pixel_review": "All 16 final captures opened with native view_image. Error/reconciliation copy and reload controls remain readable at 320px; current-org identity, retained drafts and disabled read-only controls are visible. The existing member grid scrolls horizontally on narrow screens; interactions reached its actions.",+ "evidence": [+ "RECEIPTS.md",+ "BROWSER-SUMMARY.json",+ "PIXEL-REVIEW.json",+ "CURRENT.tar.xz",+ "final-captures/browser-result.json"+ ],+ "limitations": "Safe synthetic HTTP fixtures, not a private hosted installation, native SSO recovery, published release or customer acceptance. The initial proxy-identity regression and unsuccessful fixture attempts remain retained separately."+}diff --git a/frontend-modern/src/api/__tests__/orgs.access.test.ts b/frontend-modern/src/api/__tests__/orgs.access.test.tsnew file mode 100644index 0000000000..ea4a0a96f2--- /dev/null+++ b/frontend-modern/src/api/__tests__/orgs.access.test.ts@@ -0,0 +1,179 @@+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';+import { OrgsAPI, type OrganizationAccessRequestOptions } from '../orgs';+import { apiClient, clearApiToken, getOrgID, setApiToken, setOrgID } from '@/utils/apiClient';++const mockFetch = vi.fn();+const accessRequests: {+ name: string;+ run: (options: OrganizationAccessRequestOptions) => Promise<unknown>;+ path: string;+ method: string;+}[] = [+ {+ name: 'organization',+ run: (options) => OrgsAPI.get('org/a', options),+ path: '/api/orgs/org%2Fa',+ method: 'GET',+ },+ {+ name: 'members',+ run: (options) => OrgsAPI.listMembers('org/a', options),+ path: '/api/orgs/org%2Fa/members',+ method: 'GET',+ },+ {+ name: 'pending invitations',+ run: (options) => OrgsAPI.listPendingInvitations('org/a', options),+ path: '/api/orgs/org%2Fa/invitations',+ method: 'GET',+ },+ {+ name: 'personal invitations',+ run: (options) => OrgsAPI.listMyInvitations(options),+ path: '/api/org-invitations',+ method: 'GET',+ },+ {+ name: 'invite member',+ run: (options) =>+ OrgsAPI.inviteMember('org/a', { userId: 'new-user', role: 'viewer' }, options),+ path: '/api/orgs/org%2Fa/members',+ method: 'POST',+ },+ {+ name: 'update role',+ run: (options) =>+ OrgsAPI.updateMemberRole('org/a', { userId: 'existing-user', role: 'editor' }, options),+ path: '/api/orgs/org%2Fa/members',+ method: 'POST',+ },+ {+ name: 'remove member',+ run: (options) => OrgsAPI.removeMember('org/a', 'user/b', options),+ path: '/api/orgs/org%2Fa/members/user%2Fb',+ method: 'DELETE',+ },+ {+ name: 'revoke invitation',+ run: (options) => OrgsAPI.revokeInvitation('org/a', 'user/b', options),+ path: '/api/orgs/org%2Fa/invitations/user%2Fb',+ method: 'DELETE',+ },+ {+ name: 'accept personal invitation',+ run: (options) => OrgsAPI.acceptMyInvitation('inviting/org', options),+ path: '/api/org-invitations/inviting%2Forg/accept',+ method: 'POST',+ },+ {+ name: 'decline personal invitation',+ run: (options) => OrgsAPI.declineMyInvitation('inviting/org', options),+ path: '/api/org-invitations/inviting%2Forg',+ method: 'DELETE',+ },+];+const options = (): OrganizationAccessRequestOptions => ({+ expectedOrgID: 'org-a',+ retry: false,+ signal: new AbortController().signal,+});++beforeEach(() => {+ vi.useRealTimers();+ mockFetch.mockReset();+ vi.stubGlobal('fetch', mockFetch);+ window.sessionStorage.clear();+ window.localStorage.clear();+ clearApiToken();+ setOrgID('org-a');+ document.cookie = 'pulse_csrf=synthetic-csrf; Path=/';+});++afterEach(() => {+ clearApiToken();+ setOrgID(null);+ vi.restoreAllMocks();+ vi.unstubAllGlobals();+});++describe('Organization Access strict transport', () => {+ it.each(accessRequests)(+ 'binds $name to the selected context, preserves session authentication and encodes target identities',+ async ({ run, path, method }) => {+ setApiToken('synthetic-token');+ mockFetch.mockResolvedValue(new Response('{}'));+ const binding = options();+ await run(binding);+ expect(mockFetch).toHaveBeenCalledTimes(1);+ const [url, request] = mockFetch.mock.calls[0];+ expect(url).toBe(path);+ expect(request.method ?? 'GET').toBe(method);+ expect(request.headers['X-Pulse-Org-ID']).toBe('org-a');+ expect(request.headers['X-API-Token']).toBeUndefined();+ expect(request.credentials).toBe('include');+ expect(request.signal).toBe(binding.signal);+ if (method !== 'GET') expect(request.headers['X-CSRF-Token']).toBeTruthy();+ },+ );++ it.each([400, 403, 429])(+ 'does not replay an access mutation or change selection after HTTP %i',+ async (status) => {+ mockFetch.mockResolvedValue(+ new Response(JSON.stringify({ error: 'invalid_org' }), {+ status,+ headers: { 'X-CSRF-Token': 'new-csrf', 'Retry-After': '1' },+ }),+ );+ await expect(+ OrgsAPI.inviteMember('org-a', { userId: 'new-user', role: 'viewer' }, options()),+ ).rejects.toThrow();+ expect(mockFetch).toHaveBeenCalledTimes(1);+ expect(getOrgID()).toBe('org-a');+ },+ );++ it('does not fall back to the stored token after a refused session read', async () => {+ setApiToken('synthetic-token');+ mockFetch.mockResolvedValue(new Response('{}', { status: 401 }));+ await expect(OrgsAPI.get('org-a', options())).rejects.toThrow();+ expect(mockFetch).toHaveBeenCalledTimes(1);+ expect(mockFetch.mock.calls[0][1].headers['X-API-Token']).toBeUndefined();+ });++ it('rejects a stale selection before dispatch, including during asynchronous CSRF preparation', async () => {+ let finish!: (value: string) => void;+ vi.spyOn(apiClient as any, 'loadCSRFToken').mockReturnValueOnce(null);+ vi.spyOn(apiClient as any, 'ensureCSRFToken').mockReturnValueOnce(+ new Promise((resolve) => {+ finish = resolve;+ }),+ );+ const pending = OrgsAPI.removeMember('org-a', 'user-2', options());+ setOrgID('org-b');+ finish('synthetic-csrf');+ await expect(pending).rejects.toThrow('Organisation changed');+ expect(mockFetch).not.toHaveBeenCalled();+ await expect(OrgsAPI.get('org-a', options())).rejects.toThrow('Organisation changed');+ expect(mockFetch).not.toHaveBeenCalled();+ });++ it('does not dispatch after a controller was invalidated while CSRF was pending', async () => {+ let finish!: (value: string) => void;+ vi.spyOn(apiClient as any, 'loadCSRFToken').mockReturnValueOnce(null);+ vi.spyOn(apiClient as any, 'ensureCSRFToken').mockReturnValueOnce(+ new Promise((resolve) => {+ finish = resolve;+ }),+ );+ const controller = new AbortController();+ const pending = OrgsAPI.declineMyInvitation('inviting-org', {+ ...options(),+ signal: controller.signal,+ });+ controller.abort();+ finish('synthetic-csrf');+ await expect(pending).rejects.toMatchObject({ name: 'AbortError' });+ expect(mockFetch).not.toHaveBeenCalled();+ });+});diff --git a/frontend-modern/src/api/orgs.ts b/frontend-modern/src/api/orgs.tsindex ee72d9eb66..529f647c20 100644--- a/frontend-modern/src/api/orgs.ts+++ b/frontend-modern/src/api/orgs.ts@@ -61,6 +61,15 @@ export interface IncomingOrganizationShare extends OrganizationShare {sourceOrgName: string;}+// Organization Access can bind an explicit read or change to the selection+// that produced it, including the pre-dispatch CSRF wait. Other callers keep+// their existing transport behaviour unless they opt in.+export interface OrganizationAccessRequestOptions {+ expectedOrgID: string;+ signal: AbortSignal;+ retry: false;+}+export const OrgsAPI = {list: () =>apiFetchJSON<Organization[]>('/api/orgs', {@@ -76,10 +85,11 @@ export const OrgsAPI = {skipOrgContext: true,}),- get: (id: string) =>+ get: (id: string, options?: OrganizationAccessRequestOptions) =>apiFetchJSON<Organization>(`/api/orgs/${encodeURIComponent(id)}`, {preferSessionAuth: true,skipOrgContext: true,+ ...options,}),update: (id: string, payload: { displayName: string }) =>@@ -97,74 +107,91 @@ export const OrgsAPI = {skipOrgContext: true,}),- listMembers: (id: string) =>+ listMembers: (id: string, options?: OrganizationAccessRequestOptions) =>apiFetchJSON<OrganizationMember[]>(`/api/orgs/${encodeURIComponent(id)}/members`, {preferSessionAuth: true,skipOrgContext: true,+ ...options,}),- listPendingInvitations: (id: string) =>+ listPendingInvitations: (id: string, options?: OrganizationAccessRequestOptions) =>apiFetchJSON<OrganizationInvitation[]>(`/api/orgs/${encodeURIComponent(id)}/invitations`, {preferSessionAuth: true,skipOrgContext: true,+ ...options,}),- listMyInvitations: () =>+ listMyInvitations: (options?: OrganizationAccessRequestOptions) =>apiFetchJSON<UserOrganizationInvitation[]>('/api/org-invitations', {preferSessionAuth: true,skipOrgContext: true,+ ...options,}),- inviteMember: (id: string, payload: { userId: string; role: OrganizationRole }) =>+ inviteMember: (+ id: string,+ payload: { userId: string; role: OrganizationRole },+ options?: OrganizationAccessRequestOptions,+ ) =>apiFetchJSON<OrganizationAccessMutationResult>(`/api/orgs/${encodeURIComponent(id)}/members`, {method: 'POST',body: JSON.stringify(payload),preferSessionAuth: true,skipOrgContext: true,+ ...options,}),- acceptMyInvitation: (id: string) =>+ acceptMyInvitation: (id: string, options?: OrganizationAccessRequestOptions) =>apiFetchJSON<OrganizationAccessMutationResult>(`/api/org-invitations/${encodeURIComponent(id)}/accept`,{method: 'POST',preferSessionAuth: true,skipOrgContext: true,+ ...options,},),- declineMyInvitation: (id: string) =>+ declineMyInvitation: (id: string, options?: OrganizationAccessRequestOptions) =>apiFetchJSON<void>(`/api/org-invitations/${encodeURIComponent(id)}`, {method: 'DELETE',preferSessionAuth: true,skipOrgContext: true,+ ...options,}),- updateMemberRole: (id: string, payload: { userId: string; role: OrganizationRole }) =>+ updateMemberRole: (+ id: string,+ payload: { userId: string; role: OrganizationRole },+ options?: OrganizationAccessRequestOptions,+ ) =>apiFetchJSON<OrganizationAccessMutationResult>(`/api/orgs/${encodeURIComponent(id)}/members`, {method: 'POST',body: JSON.stringify(payload),preferSessionAuth: true,skipOrgContext: true,+ ...options,}),- revokeInvitation: (id: string, userId: string) =>+ revokeInvitation: (id: string, userId: string, options?: OrganizationAccessRequestOptions) =>apiFetchJSON<void>(`/api/orgs/${encodeURIComponent(id)}/invitations/${encodeURIComponent(userId)}`,{method: 'DELETE',preferSessionAuth: true,skipOrgContext: true,+ ...options,},),- removeMember: (id: string, userId: string) =>+ removeMember: (id: string, userId: string, options?: OrganizationAccessRequestOptions) =>apiFetchJSON<void>(`/api/orgs/${encodeURIComponent(id)}/members/${encodeURIComponent(userId)}`,{method: 'DELETE',preferSessionAuth: true,skipOrgContext: true,+ ...options,},),diff --git a/frontend-modern/src/components/Settings/OrganizationAccessInvitationsSection.tsx b/frontend-modern/src/components/Settings/OrganizationAccessInvitationsSection.tsxindex 463e81fd4d..0f2ce43f94 100644--- a/frontend-modern/src/components/Settings/OrganizationAccessInvitationsSection.tsx+++ b/frontend-modern/src/components/Settings/OrganizationAccessInvitationsSection.tsx@@ -39,7 +39,7 @@ export const OrganizationAccessInvitationsSection: Component<variant="primary"size="mdCompact"onClick={() => void props.state.acceptInvitation(invitation.orgId)}- disabled={props.state.saving()}+ disabled={!props.state.canChangeAccess()}>Accept</Button>@@ -47,7 +47,7 @@ export const OrganizationAccessInvitationsSection: Component<variant="dangerOutline"size="mdCompact"onClick={() => void props.state.declineInvitation(invitation.orgId)}- disabled={props.state.saving()}+ disabled={!props.state.canChangeAccess()}>Decline</Button>@@ -82,7 +82,7 @@ export const OrganizationAccessInvitationsSection: Component<variant="dangerOutline"size="mdCompact"onClick={() => void props.state.revokeInvitation(invitation.userId)}- disabled={props.state.saving()}+ disabled={!props.state.canChangeAccess()}>Revoke</Button>diff --git a/frontend-modern/src/components/Settings/OrganizationAccessManagementSection.tsx b/frontend-modern/src/components/Settings/OrganizationAccessManagementSection.tsxindex b611513cfc..c409a35c77 100644--- a/frontend-modern/src/components/Settings/OrganizationAccessManagementSection.tsx+++ b/frontend-modern/src/components/Settings/OrganizationAccessManagementSection.tsx@@ -23,6 +23,7 @@ export const OrganizationAccessManagementSection: Component<<div class="grid gap-2 sm:grid-cols-[1fr_auto_auto]"><inputtype="text"+ aria-label="Invite user ID"value={props.state.inviteUserID()}onInput={(event) => props.state.setInviteUserID(event.currentTarget.value)}placeholder="username"@@ -62,7 +63,7 @@ export const OrganizationAccessManagementSection: Component<<Show when={!props.state.canManageCurrentOrg()}><div class="rounded-md border border-amber-200 bg-amber-50 p-3 text-sm text-amber-800 dark:border-amber-800 dark:bg-amber-900/25 dark:text-amber-300">- {getOrganizationAccessManageRequiredMessage()}+ {getOrganizationAccessManageRequiredMessage(props.state.readOnly())}</div></Show></>diff --git a/frontend-modern/src/components/Settings/OrganizationAccessPanel.tsx b/frontend-modern/src/components/Settings/OrganizationAccessPanel.tsxindex 8f656fcc87..902dcfc5b3 100644--- a/frontend-modern/src/components/Settings/OrganizationAccessPanel.tsx+++ b/frontend-modern/src/components/Settings/OrganizationAccessPanel.tsx@@ -1,8 +1,13 @@import { Component, Show } from 'solid-js';+import { Button } from '@/components/shared/Button';+import { Card } from '@/components/shared/Card';import SettingsPanel from '@/components/shared/SettingsPanel';import { isMultiTenantEnabled } from '@/stores/license';import { presentationPolicyHidesOrganizationSurfaces } from '@/stores/sessionPresentationPolicy';import {+ getOrganizationAccessReloadMessage,+ ORGANIZATION_ACCESS_RELOAD_LABEL,+ ORGANIZATION_ACCESS_UNAVAILABLE_TITLE,ORGANIZATION_SETTINGS_UNAVAILABLE_CLASS,ORGANIZATION_SETTINGS_UNAVAILABLE_MESSAGE,} from '@/utils/organizationSettingsPresentation';@@ -33,10 +38,40 @@ export const OrganizationAccessPanel: Component<OrganizationAccessPanelProps> =<div class="space-y-6"><SettingsPanel title="Organization Access" bodyClass="space-y-5"><Show when={!state.loading()} fallback={<OrganizationAccessLoadingState />}>- <Show when={state.org()}>- <OrganizationAccessInvitationsSection state={state} />- <OrganizationAccessManagementSection state={state} currentUser={props.currentUser} />- <OrganizationAccessMembersSection state={state} currentUser={props.currentUser} />+ <Show when={state.loadError()}>+ <Card tone="warning" padding="md">+ <div role="alert" class="space-y-3 text-sm">+ <p class="font-semibold">{ORGANIZATION_ACCESS_UNAVAILABLE_TITLE}</p>+ <p>{state.loadError()}</p>+ <p>{getOrganizationAccessReloadMessage(state.selectedOrgID())}</p>+ <Button+ onClick={() => void state.loadOrganizationAccess()}+ disabled={state.loading() || state.saving()}+ class="w-full sm:w-auto"+ >+ {ORGANIZATION_ACCESS_RELOAD_LABEL}+ </Button>+ </div>+ </Card>+ </Show>+ <Show when={!state.loadError() && state.org()}>+ {(currentOrg) => (+ <>+ <p class="text-sm text-muted break-words">+ Access for{' '}+ <span class="font-medium text-base-content">+ {currentOrg().displayName || currentOrg().id}+ </span>{' '}+ ({currentOrg().id})+ </p>+ <OrganizationAccessInvitationsSection state={state} />+ <OrganizationAccessManagementSection+ state={state}+ currentUser={props.currentUser}+ />+ <OrganizationAccessMembersSection state={state} currentUser={props.currentUser} />+ </>+ )}</Show></Show></SettingsPanel>diff --git a/frontend-modern/src/components/Settings/__tests__/OrganizationAccessPanel.test.tsx b/frontend-modern/src/components/Settings/__tests__/OrganizationAccessPanel.test.tsxindex 21b1860caf..db117827c1 100644--- a/frontend-modern/src/components/Settings/__tests__/OrganizationAccessPanel.test.tsx+++ b/frontend-modern/src/components/Settings/__tests__/OrganizationAccessPanel.test.tsx@@ -1,5 +1,8 @@+import { createSignal } from 'solid-js';+import { useOrganizationAccessPanelState } from '../useOrganizationAccessPanelState';+import type { OrganizationMember } from '@/api/orgs';import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';-import { cleanup, render, screen, waitFor } from '@solidjs/testing-library';+import { cleanup, fireEvent, render, screen, waitFor } from '@solidjs/testing-library';import { OrganizationAccessPanel } from '../OrganizationAccessPanel';import organizationAccessStateSource from '../useOrganizationAccessPanelState.ts?raw';@@ -20,6 +23,11 @@ const notificationErrorMock = vi.fn();const eventBusOnMock = vi.fn();const eventBusEmitMock = vi.fn();const loggerErrorMock = vi.fn();+const readOnlyMock = vi.fn();+const hideOrganizationsMock = vi.fn();+let setEnabled: (enabled: boolean) => void;+let setReadOnly: (readOnly: boolean) => void;+const listeners = new Map<string, Set<() => void>>();vi.mock('@/api/orgs', () => ({OrgsAPI: {@@ -40,6 +48,11 @@ vi.mock('@/stores/license', () => ({isMultiTenantEnabled: (...args: unknown[]) => isMultiTenantEnabledMock(...args),}));+vi.mock('@/stores/sessionPresentationPolicy', () => ({+ presentationPolicyHidesOrganizationSurfaces: () => hideOrganizationsMock(),+ presentationPolicyIsReadOnly: () => readOnlyMock(),+}));+vi.mock('@/utils/apiClient', () => ({getOrgID: (...args: unknown[]) => getOrgIDMock(...args),}));@@ -114,16 +127,37 @@ beforeEach(() => {eventBusEmitMock.mockReset();loggerErrorMock.mockReset();- isMultiTenantEnabledMock.mockReturnValue(true);+ const [enabled, updateEnabled] = createSignal(true);+ const [readOnly, updateReadOnly] = createSignal(false);+ setEnabled = updateEnabled;+ setReadOnly = updateReadOnly;+ isMultiTenantEnabledMock.mockImplementation(enabled);+ readOnlyMock.mockImplementation(readOnly);+ hideOrganizationsMock.mockReturnValue(false);+ vi.stubGlobal(+ 'confirm',+ vi.fn(() => true),+ );getOrgIDMock.mockReturnValue('org-a');- eventBusOnMock.mockReturnValue(() => undefined);+ listeners.clear();+ eventBusOnMock.mockImplementation((event, callback) => {+ if (!listeners.has(event)) listeners.set(event, new Set());+ listeners.get(event)!.add(callback);+ return () => listeners.get(event)?.delete(callback);+ });+ eventBusEmitMock.mockImplementation((event) => {+ listeners.get(event)?.forEach((callback) => callback());+ });orgGetMock.mockResolvedValue(baseOrg);listMembersMock.mockResolvedValue(baseMembers);listPendingInvitationsMock.mockResolvedValue([]);listMyInvitationsMock.mockResolvedValue([]);updateMemberRoleMock.mockResolvedValue(undefined);- inviteMemberMock.mockResolvedValue({ kind: 'invitation' });+ inviteMemberMock.mockResolvedValue({+ kind: 'invitation',+ invitation: { userId: 'new-user', role: 'viewer' },+ });acceptMyInvitationMock.mockResolvedValue({ kind: 'member' });declineMyInvitationMock.mockResolvedValue(undefined);revokeInvitationMock.mockResolvedValue(undefined);@@ -132,6 +166,7 @@ beforeEach(() => {afterEach(() => {cleanup();+ vi.unstubAllGlobals();});describe('OrganizationAccessPanel', () => {@@ -151,8 +186,503 @@ describe('OrganizationAccessPanel', () => {});});+ it.each(['role', 'remove'] as const)(+ 'admits the real datagrid proxy for a current %s change',+ async (operation) => {+ renderPanel();+ await screen.findByText('user-2');+ if (operation === 'role') {+ fireEvent.change(screen.getByRole('combobox', { name: 'Role for user-2' }), {+ target: { value: 'editor' },+ });+ await waitFor(() =>+ expect(updateMemberRoleMock).toHaveBeenCalledWith(+ 'org-a',+ { userId: 'user-2', role: 'editor' },+ expect.objectContaining({ expectedOrgID: 'org-a', retry: false }),+ ),+ );+ } else {+ fireEvent.click(screen.getByRole('button', { name: 'Remove', exact: true }));+ await waitFor(() =>+ expect(removeMemberMock).toHaveBeenCalledWith(+ 'org-a',+ 'user-2',+ expect.objectContaining({ expectedOrgID: 'org-a', retry: false }),+ ),+ );+ }+ },+ );+it('normalizes org scope through the shared helper', () => {expect(organizationAccessStateSource).toContain('normalizeOrgScope(getOrgID())');expect(organizationAccessStateSource).not.toContain("getOrgID() || 'default'");});});++describe('Organization Access selection safety', () => {+ it('does not restore the previous organization after a failed switch, and offers a read-only retry', async () => {+ renderPanel();+ await screen.findByText('user-2');+ getOrgIDMock.mockReturnValue('org-b');+ orgGetMock.mockRejectedValueOnce(new Error('Forbidden'));+ eventBusEmitMock('org_switched');+ await waitFor(() => expect(loggerErrorMock).toHaveBeenCalled());+ expect(screen.queryByText('user-2')).not.toBeInTheDocument();+ expect(screen.queryByRole('button', { name: 'Invite', exact: true })).not.toBeInTheDocument();+ expect(screen.getByRole('alert')).toHaveTextContent('org-b');+ expect(screen.getByRole('button', { name: 'Reload access' })).toBeInTheDocument();+ });++ it('does not let a late old read replace the current organization', async () => {+ const oldMembers = deferred<typeof baseMembers>();+ listMembersMock.mockReturnValueOnce(oldMembers.promise);+ renderPanel();+ await waitFor(() => expect(listMembersMock).toHaveBeenCalledTimes(1));+ getOrgIDMock.mockReturnValue('org-b');+ orgGetMock.mockResolvedValueOnce({ ...baseOrg, id: 'org-b', displayName: 'Organization B' });+ listMembersMock.mockResolvedValueOnce([{ ...baseMembers[1], userId: 'member-b' }]);+ eventBusEmitMock('org_switched');+ await screen.findByText('member-b');+ oldMembers.resolve(baseMembers);+ await new Promise((resolve) => setTimeout(resolve, 0));+ expect(screen.getByText('member-b')).toBeInTheDocument();+ expect(screen.queryByText('user-2')).not.toBeInTheDocument();+ });+});++const pendingInvitation = {+ userId: 'invited-user',+ role: 'viewer',+ invitedAt: '2026-10-01T00:00:00Z',+ invitedBy: 'user-1',+};+const personalInvitation = {+ ...pendingInvitation,+ userId: 'user-1',+ orgId: 'inviting-org',+ orgDisplayName: 'Inviting Organization',+};+const renderState = () => {+ let state!: ReturnType<typeof useOrganizationAccessPanelState>;+ const view = render(() => {+ state = useOrganizationAccessPanelState({ currentUser: 'user-1' });+ return <div />;+ });+ return { state, ...view };+};+const ready = async (state: ReturnType<typeof useOrganizationAccessPanelState>) => {+ await waitFor(() => expect(state.loading()).toBe(false));+ expect(state.loadError()).toBeNull();+};+const writes = () => [+ updateMemberRoleMock,+ inviteMemberMock,+ acceptMyInvitationMock,+ declineMyInvitationMock,+ revokeInvitationMock,+ removeMemberMock,+];+const expectNoWrites = () => writes().forEach((write) => expect(write).not.toHaveBeenCalled());++describe('Organization Access read admission', () => {+ it('keeps first-read failure distinct from accepted empty membership, and retries only reads', async () => {+ orgGetMock.mockRejectedValueOnce(new Error('Unavailable'));+ renderPanel();+ await screen.findByRole('alert');+ expect(screen.queryByText('No organization members found.')).not.toBeInTheDocument();+ orgGetMock.mockResolvedValue(baseOrg);+ listMembersMock.mockResolvedValue([]);+ fireEvent.click(screen.getByRole('button', { name: 'Reload access' }));+ await screen.findByText('No organization members found.');+ expect(screen.queryByRole('alert')).not.toBeInTheDocument();+ expectNoWrites();+ });++ it('preserves only the same-selection invitation draft through a failed refresh and reload', async () => {+ renderPanel();+ const input = await screen.findByRole('textbox', { name: 'Invite user ID' });+ fireEvent.input(input, { target: { value: 'unsent-user' } });+ orgGetMock.mockRejectedValueOnce(new Error('Unavailable'));+ eventBusEmitMock('organizations_changed');+ await screen.findByRole('alert');+ expect(screen.queryByText('user-2')).not.toBeInTheDocument();+ fireEvent.click(screen.getByRole('button', { name: 'Reload access' }));+ expect(await screen.findByRole('textbox', { name: 'Invite user ID' })).toHaveValue(+ 'unsent-user',+ );+ expectNoWrites();+ });++ it('does not follow an obsolete organization lookup with membership reads', async () => {+ const oldOrg = deferred<typeof baseOrg>();+ orgGetMock.mockReturnValueOnce(oldOrg.promise);+ const { state } = renderState();+ getOrgIDMock.mockReturnValue('org-b');+ orgGetMock.mockResolvedValueOnce({ ...baseOrg, id: 'org-b' });+ eventBusEmitMock('org_switched');+ await ready(state);+ oldOrg.resolve(baseOrg);+ await new Promise((resolve) => setTimeout(resolve, 0));+ expect(listMembersMock.mock.calls.map(([orgId]) => orgId)).toEqual(['org-b']);+ expect(state.org()?.id).toBe('org-b');+ });++ it.each(['late success', 'late failure'])(+ 'ignores %s from the first read after A → B → A',+ async (result) => {+ const first = deferred<typeof baseMembers>();+ listMembersMock.mockReturnValueOnce(first.promise);+ const { state } = renderState();+ await waitFor(() => expect(listMembersMock).toHaveBeenCalledTimes(1));+ getOrgIDMock.mockReturnValue('org-b');+ orgGetMock.mockResolvedValueOnce({ ...baseOrg, id: 'org-b' });+ eventBusEmitMock('org_switched');+ await ready(state);+ getOrgIDMock.mockReturnValue('org-a');+ listMembersMock.mockResolvedValueOnce([{ ...baseMembers[1], userId: 'new-snapshot' }]);+ eventBusEmitMock('org_switched');+ await ready(state);+ if (result === 'late success') first.resolve(baseMembers);+ else first.reject(new Error('Old selection failed'));+ await new Promise((resolve) => setTimeout(resolve, 0));+ expect(state.members().map((member) => member.userId)).toEqual(['new-snapshot']);+ expect(state.loadError()).toBeNull();+ expect(loggerErrorMock).not.toHaveBeenCalled();+ },+ );++ it('rejects a different organization returned by the server without reading its members', async () => {+ orgGetMock.mockResolvedValueOnce({ ...baseOrg, id: 'different-org' });+ const { state } = renderState();+ await waitFor(() => expect(state.loadError()).not.toBeNull());+ expect(state.org()).toBeNull();+ expect(listMembersMock).not.toHaveBeenCalled();+ expectNoWrites();+ });++ it.each(['members', 'pending', 'personal'] as const)(+ 'does not admit a malformed %s list as empty',+ async (list) => {+ const request = {+ members: listMembersMock,+ pending: listPendingInvitationsMock,+ personal: listMyInvitationsMock,+ }[list];+ request.mockResolvedValueOnce(null);+ const { state } = renderState();+ await waitFor(() => expect(state.loadError()).not.toBeNull());+ expect(state.org()).toBeNull();+ expect(state.canManageCurrentOrg()).toBe(false);+ },+ );++ it('binds every admitted read to the exact selected organization with one abort signal', async () => {+ const { state } = renderState();+ await ready(state);+ for (const request of [orgGetMock, listMembersMock, listPendingInvitationsMock]) {+ expect(request).toHaveBeenCalledWith(+ 'org-a',+ expect.objectContaining({+ expectedOrgID: 'org-a',+ retry: false,+ signal: expect.any(AbortSignal),+ }),+ );+ }+ expect(listMyInvitationsMock).toHaveBeenCalledWith(+ expect.objectContaining({+ expectedOrgID: 'org-a',+ retry: false,+ signal: expect.any(AbortSignal),+ }),+ );+ });++ it('normalizes deliberate default selection without accepting another payload identity', async () => {+ getOrgIDMock.mockReturnValue(null);+ orgGetMock.mockResolvedValue({ ...baseOrg, id: 'default', ownerUserId: undefined });+ const { state } = renderState();+ await ready(state);+ expect(state.org()?.id).toBe('default');+ expect(orgGetMock.mock.calls[0][1].expectedOrgID).toBe('default');+ expect(state.canManageCurrentOrg()).toBe(false);+ });+});++describe('Organization Access change safety', () => {+ beforeEach(() => {+ listPendingInvitationsMock.mockResolvedValue([pendingInvitation]);+ listMyInvitationsMock.mockResolvedValue([personalInvitation]);+ });++ const exerciseAllChanges = async (+ state: ReturnType<typeof useOrganizationAccessPanelState>,+ member: OrganizationMember,+ ) => {+ state.setInviteUserID('new-user');+ await state.inviteMember();+ await state.updateRole(member, 'editor');+ await state.removeMember(member);+ await state.revokeInvitation('invited-user');+ await state.acceptInvitation('inviting-org');+ await state.declineInvitation('inviting-org');+ };++ it.each(['pending', 'failed', 'switched without event', 'read-only', 'disabled'])(+ 'rejects every retained mutation handler when %s',+ async (reason) => {+ const { state } = renderState();+ await ready(state);+ const member = state.members()[1];+ if (reason === 'switched without event') getOrgIDMock.mockReturnValue('org-b');+ if (reason === 'read-only') setReadOnly(true);+ if (reason === 'disabled') setEnabled(false);+ if (reason === 'pending' || reason === 'failed') {+ const lookup = deferred<typeof baseOrg>();+ orgGetMock.mockReturnValueOnce(lookup.promise);+ eventBusEmitMock('organizations_changed');+ if (reason === 'failed') {+ lookup.reject(new Error('Unavailable'));+ await waitFor(() => expect(state.loadError()).not.toBeNull());+ }+ }+ await exerciseAllChanges(state, member);+ expectNoWrites();+ expect(confirm).not.toHaveBeenCalled();+ },+ );++ it.each(['invite', 'role', 'remove', 'revoke', 'accept', 'decline'] as const)(+ 'uses exactly one snapshot-bound %s mutation and blocks concurrent changes',+ async (operation) => {+ const { state } = renderState();+ await ready(state);+ const member = state.members()[1];+ const result = deferred<any>();+ const request = {+ invite: inviteMemberMock,+ role: updateMemberRoleMock,+ remove: removeMemberMock,+ revoke: revokeInvitationMock,+ accept: acceptMyInvitationMock,+ decline: declineMyInvitationMock,+ }[operation];+ request.mockReturnValueOnce(result.promise);+ state.setInviteUserID('new-user');+ const action = {+ invite: () => state.inviteMember(),+ role: () => state.updateRole(member, 'editor'),+ remove: () => state.removeMember(member),+ revoke: () => state.revokeInvitation('invited-user'),+ accept: () => state.acceptInvitation('inviting-org'),+ decline: () => state.declineInvitation('inviting-org'),+ }[operation];+ const pending = action();+ expect(state.saving()).toBe(true);+ await exerciseAllChanges(state, member);+ expect(writes().reduce((sum, write) => sum + write.mock.calls.length, 0)).toBe(1);+ expect(request.mock.calls[0].at(-1)).toMatchObject({+ expectedOrgID: 'org-a',+ retry: false,+ signal: expect.any(AbortSignal),+ });+ expect(request.mock.calls[0][0]).toBe(+ operation === 'accept' || operation === 'decline' ? 'inviting-org' : 'org-a',+ );+ result.resolve({ kind: 'member', member });+ await pending;+ await ready(state);+ expect(notificationSuccessMock).toHaveBeenCalledTimes(1);+ expect(orgGetMock).toHaveBeenCalledTimes(2);+ },+ );++ it('requires a read after a failed mutation, retaining the draft without replaying the change', async () => {+ const { state } = renderState();+ await ready(state);+ state.setInviteUserID('new-user');+ inviteMemberMock.mockRejectedValueOnce(new Error('Connection lost'));+ await state.inviteMember();+ expect(state.loadError()).toMatch(/could not be confirmed/);+ expect(state.inviteUserID()).toBe('new-user');+ await state.inviteMember();+ expect(inviteMemberMock).toHaveBeenCalledTimes(1);+ expect(orgGetMock).toHaveBeenCalledTimes(1);+ await state.loadOrganizationAccess();+ await ready(state);+ expect(inviteMemberMock).toHaveBeenCalledTimes(1);+ expect(state.inviteUserID()).toBe('new-user');+ });++ it('does not erase a newer draft on successful invite', async () => {+ const result = deferred<any>();+ inviteMemberMock.mockReturnValueOnce(result.promise);+ const { state } = renderState();+ await ready(state);+ state.setInviteUserID('first-user');+ const pending = state.inviteMember();+ state.setInviteUserID('next-user');+ result.resolve({ kind: 'member' });+ await pending;+ await ready(state);+ expect(state.inviteUserID()).toBe('next-user');+ });++ it.each(['success', 'failure'])(+ 'ignores old mutation %s after switching, without clearing the new draft or pending read',+ async (outcome) => {+ const result = deferred<any>();+ inviteMemberMock.mockReturnValueOnce(result.promise);+ const { state } = renderState();+ await ready(state);+ state.setInviteUserID('old-user');+ const pending = state.inviteMember();+ const signal = inviteMemberMock.mock.calls[0][2].signal;+ const lookup = deferred<typeof baseOrg>();+ orgGetMock.mockReturnValueOnce(lookup.promise);+ getOrgIDMock.mockReturnValue('org-b');+ eventBusEmitMock('org_switched');+ expect(signal.aborted).toBe(true);+ expect(state.inviteUserID()).toBe('');+ state.setInviteUserID('new-draft');+ if (outcome === 'success') result.resolve({ kind: 'member' });+ else result.reject(new Error('Old change failed'));+ await pending;+ expect(state.loading()).toBe(true);+ expect(state.inviteUserID()).toBe('new-draft');+ expect(notificationSuccessMock).not.toHaveBeenCalled();+ expect(notificationErrorMock).not.toHaveBeenCalled();+ lookup.resolve({ ...baseOrg, id: 'org-b' });+ await ready(state);+ expect(inviteMemberMock).toHaveBeenCalledTimes(1);+ },+ );++ it('does not accept a stale member object or absent invitation after a same-organization reload', async () => {+ const { state } = renderState();+ await ready(state);+ const staleMember = state.members()[1];+ listMembersMock.mockResolvedValue(baseMembers.map((member) => ({ ...member })));+ listPendingInvitationsMock.mockResolvedValue([]);+ listMyInvitationsMock.mockResolvedValue([]);+ await state.loadOrganizationAccess();+ await state.updateRole(staleMember, 'editor');+ await state.removeMember(staleMember);+ await state.revokeInvitation('invited-user');+ await state.acceptInvitation('inviting-org');+ await state.declineInvitation('inviting-org');+ expectNoWrites();+ });++ it('rechecks a remove confirmation against the selection that supplied it', async () => {+ const { state } = renderState();+ await ready(state);+ vi.mocked(confirm).mockImplementationOnce(() => {+ getOrgIDMock.mockReturnValue('org-b');+ return true;+ });+ await state.removeMember(state.members()[1]);+ expect(removeMemberMock).not.toHaveBeenCalled();+ });++ it('preserves the owner and existing-member ownership transfer rules', async () => {+ const { state } = renderState();+ await ready(state);+ await state.removeMember(state.members()[0]);+ await state.updateRole(state.members()[0], 'viewer');+ state.setInviteUserID('not-a-member');+ state.setInviteRole('owner');+ await state.inviteMember();+ expectNoWrites();+ expect(notificationErrorMock).toHaveBeenCalledWith(+ 'Ownership can only be transferred to an existing member.',+ );+ });++ it('allows a viewer to answer their own invitation but not manage members or pending invitations', async () => {+ orgGetMock.mockResolvedValue({+ ...baseOrg,+ ownerUserId: 'someone-else',+ members: baseMembers.map((member) => ({ ...member, role: 'viewer' })),+ });+ const { state } = renderState();+ await ready(state);+ expect(state.canManageCurrentOrg()).toBe(false);+ expect(listPendingInvitationsMock).not.toHaveBeenCalled();+ state.setInviteUserID('new-user');+ await state.inviteMember();+ await state.updateRole(state.members()[1], 'admin');+ await state.removeMember(state.members()[1]);+ expect(inviteMemberMock).not.toHaveBeenCalled();+ expect(updateMemberRoleMock).not.toHaveBeenCalled();+ expect(removeMemberMock).not.toHaveBeenCalled();+ await state.acceptInvitation('inviting-org');+ expect(acceptMyInvitationMock).toHaveBeenCalledTimes(1);+ });++ it('shows a read-only session notice instead of presenting a false role requirement', async () => {+ setReadOnly(true);+ renderPanel();+ await screen.findByText('Organization access is read-only for this session.');+ expect(screen.getByRole('button', { name: 'Accept', exact: true })).toBeDisabled();+ expect(screen.getByRole('button', { name: 'Decline', exact: true })).toBeDisabled();+ expect(screen.queryByRole('textbox', { name: 'Invite user ID' })).not.toBeInTheDocument();+ expect(+ screen.queryByText('Admin or owner role required to manage organization access.'),+ ).not.toBeInTheDocument();+ });+});++describe('Organization Access lifetime', () => {+ it('invalidates reads on capability loss and reads afresh when the capability returns', async () => {+ const oldMembers = deferred<typeof baseMembers>();+ listMembersMock.mockReturnValueOnce(oldMembers.promise);+ const { state } = renderState();+ await waitFor(() => expect(listMembersMock).toHaveBeenCalledTimes(1));+ const signal = listMembersMock.mock.calls[0][1].signal;+ setEnabled(false);+ await waitFor(() => expect(state.loading()).toBe(false));+ expect(signal.aborted).toBe(true);+ oldMembers.resolve(baseMembers);+ await new Promise((resolve) => setTimeout(resolve, 0));+ expect(state.org()).toBeNull();+ setEnabled(true);+ await ready(state);+ expect(orgGetMock).toHaveBeenCalledTimes(2);+ expect(state.members()).toEqual(baseMembers);+ });++ it('invalidates an older identity and clears its draft even in the same organization', async () => {+ const [currentUser, setCurrentUser] = createSignal('user-1');+ render(() => <OrganizationAccessPanel currentUser={currentUser()} />);+ fireEvent.input(await screen.findByRole('textbox', { name: 'Invite user ID' }), {+ target: { value: 'private-draft' },+ });+ const pending = deferred<typeof baseMembers>();+ listMembersMock.mockReturnValueOnce(pending.promise);+ eventBusEmitMock('organizations_changed');+ await waitFor(() => expect(listMembersMock).toHaveBeenCalledTimes(2));+ orgGetMock.mockResolvedValue({ ...baseOrg, ownerUserId: 'user-b' });+ setCurrentUser('user-b');+ expect(await screen.findByRole('textbox', { name: 'Invite user ID' })).toHaveValue('');+ pending.reject(new Error('Old identity failed'));+ await new Promise((resolve) => setTimeout(resolve, 0));+ expect(screen.queryByRole('alert')).not.toBeInTheDocument();+ });++ it('aborts reads and unsubscribes on disposal without emitting late errors', async () => {+ const pending = deferred<typeof baseOrg>();+ orgGetMock.mockReturnValueOnce(pending.promise);+ const { unmount } = renderState();+ const signal = orgGetMock.mock.calls[0][1].signal;+ unmount();+ expect(signal.aborted).toBe(true);+ pending.reject(new Error('Disposed read'));+ await new Promise((resolve) => setTimeout(resolve, 0));+ expect(loggerErrorMock).not.toHaveBeenCalled();+ eventBusEmitMock('org_switched');+ expect(orgGetMock).toHaveBeenCalledTimes(1);+ });+});diff --git a/frontend-modern/src/components/Settings/useOrganizationAccessPanelState.ts b/frontend-modern/src/components/Settings/useOrganizationAccessPanelState.tsindex 51e5f718a5..aca9c9439e 100644--- a/frontend-modern/src/components/Settings/useOrganizationAccessPanelState.ts+++ b/frontend-modern/src/components/Settings/useOrganizationAccessPanelState.ts@@ -1,7 +1,9 @@-import { createMemo, createSignal, onCleanup, onMount } from 'solid-js';+import { batch, createEffect, createMemo, createSignal, on, onCleanup } from 'solid-js';+import { unwrap } from 'solid-js/store';import {OrgsAPI,type Organization,+ type OrganizationAccessRequestOptions,type OrganizationInvitation,type OrganizationMember,type OrganizationRole,@@ -10,7 +12,10 @@ import {import { eventBus } from '@/stores/events';import { isMultiTenantEnabled } from '@/stores/license';import { notificationStore } from '@/stores/notifications';-import { presentationPolicyHidesOrganizationSurfaces } from '@/stores/sessionPresentationPolicy';+import {+ presentationPolicyHidesOrganizationSurfaces,+ presentationPolicyIsReadOnly,+} from '@/stores/sessionPresentationPolicy';import { getOrgID } from '@/utils/apiClient';import { logger } from '@/utils/logger';import { normalizeOrgScope } from '@/utils/orgScope';@@ -33,6 +38,7 @@ import {getOrganizationOwnerRoleLockedMessage,getOrganizationRemoveMemberErrorMessage,getOrganizationSettingsLoadErrorMessage,+ ORGANIZATION_ACCESS_UNCONFIRMED_CHANGE_MESSAGE,} from '@/utils/organizationSettingsPresentation';import { canManageOrg, normalizeRole } from '@/utils/orgUtils';@@ -42,6 +48,7 @@ interface OrganizationAccessPanelProps {export function useOrganizationAccessPanelState(props: OrganizationAccessPanelProps) {const [loading, setLoading] = createSignal(true);+ const [loadError, setLoadError] = createSignal<string | null>(null);const [saving, setSaving] = createSignal(false);const [org, setOrg] = createSignal<Organization | null>(null);const [members, setMembers] = createSignal<OrganizationMember[]>([]);@@ -51,218 +58,310 @@ export function useOrganizationAccessPanelState(props: OrganizationAccessPanelPrconst [inviteRole, setInviteRole] = createSignal<OrganizationRole>('viewer');const activeOrgId = () => normalizeOrgScope(getOrgID());- const canManageCurrentOrg = createMemo(() => canManageOrg(org(), props.currentUser));+ const [selectedOrgID, setSelectedOrgID] = createSignal(activeOrgId());+ const [selectedUser, setSelectedUser] = createSignal(props.currentUser);+ let generation = 0;+ let disposed = false;+ let readController: AbortController | undefined;+ let mutationController: AbortController | undefined;+ const surfaceEnabled = () =>+ isMultiTenantEnabled() && !presentationPolicyHidesOrganizationSurfaces();+ const selectionIsCurrent = () =>+ !disposed &&+ surfaceEnabled() &&+ selectedOrgID() === activeOrgId() &&+ selectedUser() === props.currentUser;+ const hasCurrentAccess = () =>+ selectionIsCurrent() && !loading() && !loadError() && org()?.id === activeOrgId();+ const canManageCurrentOrg = createMemo(+ () =>+ hasCurrentAccess() &&+ !presentationPolicyIsReadOnly() &&+ canManageOrg(org(), props.currentUser),+ );+ const canChangeAccess = () =>+ hasCurrentAccess() && !!props.currentUser && !presentationPolicyIsReadOnly() && !saving();++ // PulseDataGrid wraps the accepted row in a Solid store proxy. Compare its+ // underlying object, not the proxy, without admitting an older read's row.+ const isCurrentMember = (member: OrganizationMember) => members().includes(unwrap(member));++ const clearAccess = () => {+ setOrg(null);+ setMembers([]);+ setPendingInvitations([]);+ setMyInvitations([]);+ };++ const invalidateRequests = () => {+ generation += 1;+ readController?.abort();+ readController = undefined;+ mutationController?.abort();+ mutationController = undefined;+ setSaving(false);+ };const loadOrganizationAccess = async () => {- setLoading(true);+ if (disposed) return;+ invalidateRequests();+ const orgId = activeOrgId();+ const user = props.currentUser;+ const request = generation;+ const isCurrent = () => request === generation && selectionIsCurrent();+ batch(() => {+ if (selectedOrgID() !== orgId || selectedUser() !== user) {+ setInviteUserID('');+ setInviteRole('viewer');+ }+ setSelectedOrgID(orgId);+ setSelectedUser(user);+ clearAccess();+ setLoadError(null);+ setLoading(surfaceEnabled());+ });+ if (!surfaceEnabled()) return;++ const controller = new AbortController();+ readController = controller;+ const options: OrganizationAccessRequestOptions = {+ expectedOrgID: orgId,+ signal: controller.signal,+ retry: false,+ };try {- const orgId = activeOrgId();- const orgData = await OrgsAPI.get(orgId);- const manageable = canManageOrg(orgData, props.currentUser);+ const orgData = await OrgsAPI.get(orgId, options);+ if (!isCurrent()) return;+ if (!orgData || orgData.id !== orgId) {+ throw new Error('Organization access returned a different selection');+ }+ const manageable = canManageOrg(orgData, user);const [memberData, invitationData, myInvitationData] = await Promise.all([- OrgsAPI.listMembers(orgId),- manageable ? OrgsAPI.listPendingInvitations(orgId) : Promise.resolve([]),- OrgsAPI.listMyInvitations(),+ OrgsAPI.listMembers(orgId, options),+ manageable ? OrgsAPI.listPendingInvitations(orgId, options) : Promise.resolve([]),+ OrgsAPI.listMyInvitations(options),]);- setOrg(orgData);- setMembers(memberData);- setPendingInvitations(invitationData);- setMyInvitations(myInvitationData);+ if (!isCurrent()) return;+ if (+ !Array.isArray(memberData) ||+ !Array.isArray(invitationData) ||+ !Array.isArray(myInvitationData)+ ) {+ throw new Error('Organization access returned invalid lists');+ }+ batch(() => {+ setOrg(orgData);+ setMembers(memberData);+ setPendingInvitations(invitationData);+ setMyInvitations(myInvitationData);+ });} catch (error) {+ if (!isCurrent()) return;logger.error('Failed to load organization access data', error);const message = error instanceof Error ? error.message : '';- notificationStore.error(getOrganizationSettingsLoadErrorMessage(message, 'access'));+ setLoadError(getOrganizationSettingsLoadErrorMessage(message, 'access'));} finally {- setLoading(false);+ if (!disposed && request === generation) {+ // Also cancel sibling reads when only one Promise.all member failed.+ controller.abort();+ readController = undefined;+ setLoading(false);+ if (!selectionIsCurrent()) void loadOrganizationAccess();+ }}};- const updateRole = async (member: OrganizationMember, role: OrganizationRole) => {- const currentOrg = org();- if (!currentOrg) return;- const currentRole = normalizeRole(member.role);- if (currentRole === role) return;-- if (member.userId === currentOrg.ownerUserId && role !== 'owner') {- notificationStore.error(getOrganizationOwnerRoleLockedMessage());- return;- }-+ const changeAccess = async <T>(+ change: (options: OrganizationAccessRequestOptions) => Promise<T>,+ successMessage: (result: T) => string,+ errorMessage: (message?: string) => string,+ afterSuccess?: () => void,+ ) => {+ if (!canChangeAccess()) return;+ const request = generation;+ const controller = new AbortController();+ mutationController = controller;setSaving(true);+ const isCurrent = () => request === generation && selectionIsCurrent();try {- await OrgsAPI.updateMemberRole(currentOrg.id, { userId: member.userId, role });- notificationStore.success(getOrganizationAccessRoleUpdatedMessage(member.userId, role));- await loadOrganizationAccess();+ const result = await change({+ expectedOrgID: selectedOrgID(),+ signal: controller.signal,+ retry: false,+ });+ if (!isCurrent()) return;+ notificationStore.success(successMessage(result));+ afterSuccess?.();+ mutationController = undefined;+ setSaving(false);+ // Refresh the accepted snapshot for every mutation, and notify the other+ // organization surfaces. Our existing subscription owns the single read.+ eventBus.emit('organizations_changed');} catch (error) {- logger.error('Failed to update member role', error);- notificationStore.error(- getOrganizationMemberRoleUpdateErrorMessage(- error instanceof Error ? error.message : undefined,- ),- );+ if (!isCurrent()) return;+ logger.error('Failed to change organization access', error);+ notificationStore.error(errorMessage(error instanceof Error ? error.message : undefined));+ // A failed response does not establish whether the server applied the+ // change. Require a read, never automatically repeat a write.+ batch(() => {+ clearAccess();+ setLoadError(ORGANIZATION_ACCESS_UNCONFIRMED_CHANGE_MESSAGE);+ });} finally {- setSaving(false);+ if (mutationController === controller) {+ mutationController = undefined;+ setSaving(false);+ if (!disposed && !selectionIsCurrent()) void loadOrganizationAccess();+ }}};- const inviteMember = async () => {- const currentOrg = org();- if (!currentOrg) return;+ const updateRole = async (member: OrganizationMember, role: OrganizationRole) => {+ if (!canChangeAccess() || !canManageCurrentOrg() || !isCurrentMember(member)) return;+ const currentOrg = org()!;+ if (normalizeRole(member.role) === role) return;+ if (+ (member.userId === currentOrg.ownerUserId && role !== 'owner') ||+ (role === 'owner' && props.currentUser !== currentOrg.ownerUserId)+ ) {+ notificationStore.error(getOrganizationOwnerRoleLockedMessage());+ return;+ }+ await changeAccess(+ (options) =>+ OrgsAPI.updateMemberRole(currentOrg.id, { userId: member.userId, role }, options),+ () => getOrganizationAccessRoleUpdatedMessage(member.userId, role),+ getOrganizationMemberRoleUpdateErrorMessage,+ );+ };- const userId = inviteUserID().trim();+ const inviteMember = async () => {+ if (!canChangeAccess() || !canManageCurrentOrg()) return;+ const currentOrg = org()!;+ const draft = inviteUserID();+ const userId = draft.trim();+ const role = inviteRole();if (!userId) {notificationStore.error(getOrganizationMemberUserIdRequiredMessage());return;}-- setSaving(true);- try {- const role = inviteRole();- if (role === 'owner' && !members().some((member) => member.userId === userId)) {+ if (role === 'owner') {+ if (props.currentUser !== currentOrg.ownerUserId) return;+ if (!members().some((member) => member.userId === userId)) {notificationStore.error(getOrganizationAccessOwnerTransferMemberRequiredMessage());return;}-- const result = await OrgsAPI.inviteMember(currentOrg.id, { userId, role });- if (result.kind === 'invitation') {- notificationStore.success(- getOrganizationAccessInvitationSentMessage(userId, result.invitation.role),- );- } else {- notificationStore.success(getOrganizationAccessMemberAddedMessage(userId, role));- }- setInviteUserID('');- setInviteRole('viewer');- await loadOrganizationAccess();- } catch (error) {- logger.error('Failed to add organization member', error);- notificationStore.error(- getOrganizationAddMemberErrorMessage(error instanceof Error ? error.message : undefined),- );- } finally {- setSaving(false);}+ await changeAccess(+ (options) => OrgsAPI.inviteMember(currentOrg.id, { userId, role }, options),+ (result) =>+ result.kind === 'invitation'+ ? getOrganizationAccessInvitationSentMessage(userId, result.invitation.role)+ : getOrganizationAccessMemberAddedMessage(userId, role),+ getOrganizationAddMemberErrorMessage,+ () => {+ if (inviteUserID() === draft && inviteRole() === role) {+ setInviteUserID('');+ setInviteRole('viewer');+ }+ },+ );};const acceptInvitation = async (orgId: string) => {- setSaving(true);- try {- await OrgsAPI.acceptMyInvitation(orgId);- notificationStore.success(- getOrganizationAccessInvitationAcceptedMessage(props.currentUser || 'user'),- );- eventBus.emit('organizations_changed');- await loadOrganizationAccess();- } catch (error) {- logger.error('Failed to accept organization invitation', error);- notificationStore.error(- getOrganizationInvitationActionErrorMessage(- error instanceof Error ? error.message : undefined,- ),- );- } finally {- setSaving(false);- }+ if (!canChangeAccess() || !myInvitations().some((invitation) => invitation.orgId === orgId))+ return;+ await changeAccess(+ (options) => OrgsAPI.acceptMyInvitation(orgId, options),+ () => getOrganizationAccessInvitationAcceptedMessage(props.currentUser!),+ getOrganizationInvitationActionErrorMessage,+ );};const declineInvitation = async (orgId: string) => {- setSaving(true);- try {- await OrgsAPI.declineMyInvitation(orgId);- notificationStore.success(getOrganizationAccessInvitationDeclinedMessage(orgId));- eventBus.emit('organizations_changed');- await loadOrganizationAccess();- } catch (error) {- logger.error('Failed to decline organization invitation', error);- notificationStore.error(- getOrganizationInvitationActionErrorMessage(- error instanceof Error ? error.message : undefined,- ),- );- } finally {- setSaving(false);- }+ if (!canChangeAccess() || !myInvitations().some((invitation) => invitation.orgId === orgId))+ return;+ await changeAccess(+ (options) => OrgsAPI.declineMyInvitation(orgId, options),+ () => getOrganizationAccessInvitationDeclinedMessage(orgId),+ getOrganizationInvitationActionErrorMessage,+ );};const revokeInvitation = async (userId: string) => {- const currentOrg = org();- if (!currentOrg) return;-- setSaving(true);- try {- await OrgsAPI.revokeInvitation(currentOrg.id, userId);- notificationStore.success(getOrganizationAccessInvitationRevokedMessage(userId));- eventBus.emit('organizations_changed');- await loadOrganizationAccess();- } catch (error) {- logger.error('Failed to revoke organization invitation', error);- notificationStore.error(- getOrganizationInvitationActionErrorMessage(- error instanceof Error ? error.message : undefined,- ),- );- } finally {- setSaving(false);- }+ if (+ !canChangeAccess() ||+ !canManageCurrentOrg() ||+ !pendingInvitations().some((invitation) => invitation.userId === userId)+ )+ return;+ const orgId = org()!.id;+ await changeAccess(+ (options) => OrgsAPI.revokeInvitation(orgId, userId, options),+ () => getOrganizationAccessInvitationRevokedMessage(userId),+ getOrganizationInvitationActionErrorMessage,+ );};const removeMember = async (member: OrganizationMember) => {- const currentOrg = org();- if (!currentOrg) return;- const organizationName = currentOrg.displayName || currentOrg.id;- if (!confirm(getOrganizationMemberRemoveConfirmMessage(member.userId, organizationName))) {+ if (!canChangeAccess() || !canManageCurrentOrg() || !isCurrentMember(member)) return;+ const currentOrg = org()!;+ if (member.userId === currentOrg.ownerUserId) return;+ if (+ !confirm(+ getOrganizationMemberRemoveConfirmMessage(+ member.userId,+ currentOrg.displayName || currentOrg.id,+ ),+ )+ )return;- }-- setSaving(true);- try {- await OrgsAPI.removeMember(currentOrg.id, member.userId);- notificationStore.success(getOrganizationAccessMemberRemovedMessage(member.userId));- await loadOrganizationAccess();- } catch (error) {- logger.error('Failed to remove organization member', error);- notificationStore.error(- getOrganizationRemoveMemberErrorMessage(error instanceof Error ? error.message : undefined),- );- } finally {- setSaving(false);- }+ // A confirmation can outlive the snapshot that supplied its member.+ if (org() !== currentOrg || !isCurrentMember(member) || !canManageCurrentOrg()) return;+ await changeAccess(+ (options) => OrgsAPI.removeMember(currentOrg.id, member.userId, options),+ () => getOrganizationAccessMemberRemovedMessage(member.userId),+ getOrganizationRemoveMemberErrorMessage,+ );};- onMount(() => {- if (!isMultiTenantEnabled() || presentationPolicyHidesOrganizationSurfaces()) {- setLoading(false);- return;- }- void loadOrganizationAccess();-- const unsubscribe = eventBus.on('org_switched', () => {- void loadOrganizationAccess();- });- const unsubscribeOrganizationsChanged = eventBus.on('organizations_changed', () => {+ const unsubscribeOrg = eventBus.on('org_switched', () => void loadOrganizationAccess());+ const unsubscribeChanged = eventBus.on(+ 'organizations_changed',+ () => void loadOrganizationAccess(),+ );+ createEffect(+ on([surfaceEnabled, () => props.currentUser, presentationPolicyIsReadOnly], () => {void loadOrganizationAccess();- });- onCleanup(() => {- unsubscribe();- unsubscribeOrganizationsChanged();- });+ }),+ );+ onCleanup(() => {+ disposed = true;+ invalidateRequests();+ unsubscribeOrg();+ unsubscribeChanged();});return {acceptInvitation,canManageCurrentOrg,+ canChangeAccess,declineInvitation,inviteMember,inviteRole,inviteUserID,loading,+ loadError,+ loadOrganizationAccess,members,myInvitations,org,pendingInvitations,+ readOnly: presentationPolicyIsReadOnly,removeMember,revokeInvitation,saving,+ selectedOrgID,setInviteRole,setInviteUserID,updateRole,diff --git a/frontend-modern/src/utils/organizationSettingsPresentation.ts b/frontend-modern/src/utils/organizationSettingsPresentation.tsindex 03c4abeac3..9a70822f12 100644--- a/frontend-modern/src/utils/organizationSettingsPresentation.ts+++ b/frontend-modern/src/utils/organizationSettingsPresentation.ts@@ -4,6 +4,13 @@ import { formatOrgDate } from '@/utils/orgUtils';export const ORGANIZATION_SETTINGS_UNAVAILABLE_MESSAGE ='Organization settings are not available on this server.';export const ORGANIZATION_SETTINGS_UNAVAILABLE_CLASS = 'p-4 text-sm text-slate-500';+export const ORGANIZATION_ACCESS_UNCONFIRMED_CHANGE_MESSAGE =+ 'The last access change could not be confirmed. Reload saved access before making another change.';+export const ORGANIZATION_ACCESS_RELOAD_LABEL = 'Reload access';+export const ORGANIZATION_ACCESS_UNAVAILABLE_TITLE = 'Organization access unavailable';+export function getOrganizationAccessReloadMessage(orgId: string): string {+ return `Reload checks saved members and invitations for ${orgId}. It does not repeat an access change.`;+}export type OrganizationSettingsLoadContext ='access' | 'overview' | 'sharing' | 'billing' | 'billing-admin';@@ -73,7 +80,8 @@ export function getOrganizationAccessOwnerTransferMemberRequiredMessage(): strinreturn 'Ownership can only be transferred to an existing member.';}-export function getOrganizationAccessManageRequiredMessage(): string {+export function getOrganizationAccessManageRequiredMessage(readOnly = false): string {+ if (readOnly) return 'Organization access is read-only for this session.';return 'Admin or owner role required to manage organization access.';}