// --------------------------------------------------------------------------- // settings / SecurityPane.tsx - W57-T36, R15 / C12. // // Every stored account owns its second factor. W59-T31 also renders this pane // before a session exists: R1 moves the enrollment screen, never the MFA wall. // Settings reads status, never the installed secret, and can replace a phone // only after password re-authentication and proof of the candidate factor. // --------------------------------------------------------------------------- import { useEffect, useLayoutEffect, useMemo, useRef, useState } from "react"; import type { FormEvent } from "react"; import { errorMessage, isAdmin, me, mfaEnrollConfirm, mfaEnrollStart, mfaStatus, regenerateRecoveryCodes, SERVER_UNAVAILABLE } from "../shell/session"; import type { MFASetup, MFAStatus, SessionUser } from "../shell/session"; import { API_V1, CREDENTIALS, checkTenant, currentTenant, signal, TOAST_EVENT, UNAUTHORIZED_EVENT } from "../apiContract"; import { useEscapeClose } from "../ui/useEscapeClose"; import { CodeInput } from "../ui/CodeInput"; import { encodeQr } from "../shell/qrcode"; import "../styles/sdlc84/settings-security.css"; function SetupQr({ uri }: { uri: string }) { const drawing = useMemo(() => { try { const qr = encodeQr(uri); const quiet = 4; // One path keeps the modal's DOM small; the four-module light border // belongs in the viewBox so responsive sizing cannot crop it away. const path = qr.modules.flatMap((row, y) => row.flatMap((dark, x) => dark ? [`M${x + quiet} ${y + quiet}h1v1h-1z`] : [])).join(""); return { extent: qr.size + 2 * quiet, path }; } catch { // Keep enrollment usable, but never draw a plausible square on failure. return null; } }, [uri]); if (!drawing) return

The QR code could not be drawn.

; return ( <>

Or scan this code with your authenticator app.

); } /** W57-T36 / C12: one show-once treatment in both doors. Copy is a quiet, * explicit export to the person's clipboard, never persistence on their behalf. * Only the acknowledgement can dismiss this surface; Escape names what remains. * Browser reload/close can only be warned about, never made impossible by a page. */ export function RecoveryCodes({ codes, onSaved, onError }: { codes: string[]; onSaved: () => void; onError: (message: string) => void; }) { const [copied, setCopied] = useState(false); const [copying, setCopying] = useState(false); useEscapeClose(true, () => onError("Save your recovery codes before continuing.")); useEffect(() => { const warn = (event: BeforeUnloadEvent) => { event.preventDefault(); event.returnValue = ""; }; window.addEventListener("beforeunload", warn); return () => window.removeEventListener("beforeunload", warn); }, []); async function copy() { if (copying) return; setCopying(true); try { await navigator.clipboard.writeText(codes.join("\n")); setCopied(true); onError(""); } catch { setCopied(false); onError("Copy did not work. Select the codes and copy them manually."); } finally { setCopying(false); } } return ( <>

These recovery codes are shown only once.

Save them somewhere safe. Each code works once if you lose your authenticator.

{copied ? "Copied" : ""}
{/* A type=button acknowledgement cannot be submitted by Enter left over from the previous code field. There is no Back or secondary exit. */} ); } type AuthFailure = { ok: false; message: string }; function showRefusal(text: string) { window.dispatchEvent(new CustomEvent(TOAST_EVENT, { detail: { text, tone: "error" } })); } // Keep the literal fetch doors visible to D-48. These session-scoped helpers // mirror authPost's tenant guard and error policy without creating a second session module. async function startDevice(password: string): Promise<({ ok: true } & MFASetup) | AuthFailure> { let res: Response; try { res = await fetch(`${API_V1}/auth/mfa/device`, { method: "POST", credentials: CREDENTIALS, cache: "no-store", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ password }), }); } catch { return { ok: false, message: errorMessage(0, null) }; } if (checkTenant(res)) return { ok: false, message: SERVER_UNAVAILABLE }; const body = await res.json().catch(() => null); if (!res.ok) return { ok: false, message: errorMessage(res.status, body) }; if (!body || typeof body.secret !== "string" || !body.secret.trim() || typeof body.otpauthUri !== "string" || !body.otpauthUri.trim() || typeof body.issuer !== "string" || !body.issuer.trim()) return { ok: false, message: SERVER_UNAVAILABLE }; return { ok: true, secret: body.secret, otpauthUri: body.otpauthUri, issuer: body.issuer }; } async function confirmDevice(password: string, secret: string, code: string): Promise< { ok: true; recoveryCodes: string[] } | AuthFailure > { let res: Response; try { res = await fetch(`${API_V1}/auth/mfa/device/confirm`, { method: "POST", credentials: CREDENTIALS, cache: "no-store", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ password, secret, code }), }); } catch { return { ok: false, message: errorMessage(0, null) }; } if (checkTenant(res)) return { ok: false, message: SERVER_UNAVAILABLE }; const body = await res.json().catch(() => null); if (!res.ok) return { ok: false, message: errorMessage(res.status, body) }; const codes: unknown = body?.recoveryCodes; // Accept the whole fresh set or refuse success, just like the existing issuers. if (!Array.isArray(codes) || codes.length === 0 || !codes.every((value): value is string => typeof value === "string" && value.trim().length > 0) || new Set(codes).size !== codes.length) return { ok: false, message: SERVER_UNAVAILABLE }; return { ok: true, recoveryCodes: codes }; } export type EnrolmentGate = { username: string; password: string; onEnrolled: (user: SessionUser, recoveryCodes: string[]) => void; onBack: () => void; }; type SecurityEvent = { kind: string; user: string; tenant: string; detail: Record; at: string; }; const EVENTS_UNAVAILABLE = "Security events could not be loaded."; const EVENT_LABELS: Record = { "auth.login": "Signed in", "auth.login_failed": "Sign-in failed", "auth.lockout": "Account locked", "auth.mfa_enrolled": "Two-step sign-in set up", "auth.mfa_failed": "Two-step sign-in failed", "auth.logout": "Signed out", "admin.grant": "Access changed", "credential.added": "Credential added", "credential.rotated": "Credential replaced", "credential.revoked": "Credential revoked", "amazon.sync": "Amazon sync", "amazon.throttled": "Amazon request limited", "amazon.authorization_lost": "Amazon authorization lost", "amazon.deletion_scheduled": "Amazon deletion scheduled", "amazon.personal_read": "Amazon personal data read", "customer.personal_read": "Customer personal data read", "data.purge": "Data deleted", "data.restore": "Data restored", "config.changed": "Setting changed", "external.query": "External query", "external.write": "External change", }; function readableLabel(value: string) { const words = value.replace(/[._-]+/g, " ").trim().toLowerCase(); return words ? words[0].toUpperCase() + words.slice(1) : "Security event"; } function SecuritySkeleton({ label }: { label: string }) { return
; } function SecurityEvents() { const [denied, setDenied] = useState(false); const [events, setEvents] = useState([]); const [loading, setLoading] = useState(true); const [problem, setProblem] = useState(""); const [revision, setRevision] = useState(0); useEffect(() => { const controller = new AbortController(); let active = true; const clear = () => { active = false; controller.abort(); setDenied(true); setEvents([]); setProblem(""); setLoading(false); }; setDenied(false); setEvents([]); setLoading(true); setProblem(""); async function load() { try { const identity = await me(); if (!active) return; if (!identity?.tenant) throw new Error(EVENTS_UNAVAILABLE); if (currentTenant() !== null && currentTenant() !== identity.tenant) { setDenied(true); return; } if (!isAdmin(identity)) { setDenied(true); return; } const response = await fetch(`${API_V1}/security/events`, { credentials: CREDENTIALS, cache: "no-store", signal: controller.signal, }); if (!active || checkTenant(response)) return; if (response.status === 401) { signal(UNAUTHORIZED_EVENT); return; } if (response.status === 403) { setDenied(true); return; } if (!response.ok) throw new Error(EVENTS_UNAVAILABLE); const body = await response.json(); if (!active) return; if (!body || !Array.isArray(body.events)) throw new Error(EVENTS_UNAVAILABLE); const entries: SecurityEvent[] = []; for (const event of body.events) { if (!event || event.tenant !== identity.tenant) continue; if (typeof event.kind !== "string" || !event.kind.trim() || typeof event.principal !== "string" || !event.principal.trim() || !event.detail || typeof event.detail !== "object" || Array.isArray(event.detail) || !Object.values(event.detail).every((value) => typeof value === "string" || typeof value === "boolean" || (typeof value === "number" && Number.isFinite(value))) || typeof event.ts !== "number" || !Number.isFinite(event.ts) || !Number.isFinite(new Date(event.ts * 1000).getTime())) throw new Error(EVENTS_UNAVAILABLE); entries.push({ kind: event.kind, user: event.principal, tenant: event.tenant, detail: event.detail, at: new Date(event.ts * 1000).toISOString() }); } setEvents(entries.reverse()); } catch { if (active) { setEvents([]); setProblem(EVENTS_UNAVAILABLE); } } finally { if (active) setLoading(false); } } window.addEventListener(UNAUTHORIZED_EVENT, clear); window.addEventListener("aios:signed-out", clear); void load(); return () => { active = false; controller.abort(); window.removeEventListener(UNAUTHORIZED_EVENT, clear); window.removeEventListener("aios:signed-out", clear); }; }, [revision]); return

Security events

{loading ? : problem ?
{problem}
: denied ?

Only administrators can view security events

: events.length ?
{events.map((event, index) => )}
EventUserDetailsTime (UTC)
{Object.hasOwn(EVENT_LABELS, event.kind) ? EVENT_LABELS[event.kind] : readableLabel(event.kind)} {event.kind} {event.user} {Object.entries(event.detail).map(([key, value]) => `${readableLabel(key)}: ${String(value)}`).join(" · ") || "No details"}
:

No security events yet

}
; } function BrowserSecurity() { const [user, setUser] = useState(null); const [enabled, setEnabled] = useState(null); const [loading, setLoading] = useState(true); const [denied, setDenied] = useState(false); const [busy, setBusy] = useState(false); const [problem, setProblem] = useState(""); const [signOutProblem, setSignOutProblem] = useState(""); const [operation, setOperation] = useState<"load" | "save" | "logout">("load"); const retryValue = useRef(null); const [revision, setRevision] = useState(0); const scope = useRef(null); const flight = useRef(false); useEffect(() => { const controller = new AbortController(); scope.current = controller; const clear = () => { controller.abort(); setUser(null); setEnabled(null); setProblem(""); setSignOutProblem(""); setBusy(false); setLoading(false); setDenied(true); flight.current = false; }; setUser(null); setEnabled(null); setProblem(""); setSignOutProblem(""); setLoading(true); setDenied(false); setOperation("load"); retryValue.current = null; async function load() { try { const identity = await me(); if (controller.signal.aborted) return; if (!identity?.tenant) throw new Error("identity"); if (currentTenant() !== null && currentTenant() !== identity.tenant) { setDenied(true); return; } setUser(identity); if (!isAdmin(identity)) { setDenied(true); return; } const response = await fetch(`${API_V1}/security/trusted-browser`, { credentials: CREDENTIALS, cache: "no-store", signal: controller.signal, }); if (controller.signal.aborted || checkTenant(response)) return; if (response.status === 401) { signal(UNAUTHORIZED_EVENT); return; } if (response.status === 403) { setDenied(true); return; } const body: unknown = await response.json().catch(() => null); if (controller.signal.aborted) return; if (!response.ok || !body || typeof (body as { enabled?: unknown }).enabled !== "boolean") throw new Error("policy"); setEnabled((body as { enabled: boolean }).enabled); } catch { if (!controller.signal.aborted) setProblem("Remembered browser settings could not be loaded."); } finally { if (!controller.signal.aborted) setLoading(false); } } window.addEventListener(UNAUTHORIZED_EVENT, clear); window.addEventListener("aios:signed-out", clear); void load(); return () => { controller.abort(); window.removeEventListener(UNAUTHORIZED_EVENT, clear); window.removeEventListener("aios:signed-out", clear); }; }, [revision]); async function save(next: boolean) { const request = scope.current?.signal; if (!request || request.aborted || flight.current || !isAdmin(user) || denied || enabled === null) return; flight.current = true; setBusy(true); setProblem(""); setOperation("save"); retryValue.current = next; try { const response = await fetch(`${API_V1}/security/trusted-browser`, { method: "PUT", credentials: CREDENTIALS, cache: "no-store", signal: request, headers: { "Content-Type": "application/json" }, body: JSON.stringify({ enabled: next }), }); if (request.aborted || checkTenant(response)) return; if (response.status === 401) { signal(UNAUTHORIZED_EVENT); return; } if (response.status === 403) { setDenied(true); return; } const body: unknown = await response.json().catch(() => null); if (request.aborted) return; if (!response.ok || !body || typeof (body as { enabled?: unknown }).enabled !== "boolean") throw new Error("policy"); setEnabled((body as { enabled: boolean }).enabled); } catch { if (!request.aborted) setProblem("Remembered browser settings could not be saved."); } finally { if (!request.aborted) { flight.current = false; setBusy(false); } } } async function signOutEverywhere() { const request = scope.current?.signal; if (!request || request.aborted || flight.current || !user) return; flight.current = true; setBusy(true); setSignOutProblem(""); setOperation("logout"); try { const response = await fetch(`${API_V1}/auth/logout-everywhere`, { method: "POST", credentials: CREDENTIALS, cache: "no-store", signal: request, }); if (request.aborted || checkTenant(response)) return; if (response.status === 401) { signal(UNAUTHORIZED_EVENT); return; } if (!response.ok) throw new Error("sign out"); signal(UNAUTHORIZED_EVENT); } catch { if (!request.aborted) setSignOutProblem("Your account could not be signed out everywhere."); } finally { if (!request.aborted) { flight.current = false; setBusy(false); } } } return <>

Remembered browsers

Allow browsers to skip two-step sign-in for 7 days

{loading ? : denied ?

Only administrators can change this setting

: null} {problem ?
{problem}
: null}

Sign out everywhere

End all sessions for your account, including this one

{loading ? : !user ?

Sign-out controls are unavailable until your account loads

: null} {signOutProblem ?
{signOutProblem}
: null}
; } export default function SecurityPane({ gate }: { gate?: EnrolmentGate } = {}) { const [status, setStatus] = useState(null); const [loading, setLoading] = useState(true); const [reload, setReload] = useState(0); const [password, setPassword] = useState(""); const [busy, setBusy] = useState(false); const [codes, setCodes] = useState(null); const [error, setError] = useState(""); const [device, setDevice] = useState(false); const [recovering, setRecovering] = useState(false); const [setup, setSetup] = useState(null); const [code, setCode] = useState(""); const [preparing, setPreparing] = useState(false); const [setupRetry, setSetupRetry] = useState(0); const [enrolledUser, setEnrolledUser] = useState(null); const flight = useRef(false); const dialog = useRef(null); const passwordField = useRef(null); const recoveryAction = useRef(null); const enrolForm = useRef(null); const focusCodeOnRetry = useRef(false); const heading = useRef(null); const locked = busy || codes !== null; const gateUsername = gate?.username; const gatePassword = gate?.password; const requestScope = useRef(null); useLayoutEffect(() => { const scope = new AbortController(); requestScope.current = scope; const clear = () => { flight.current = false; focusCodeOnRetry.current = false; setPassword(""); setCode(""); setSetup(null); setCodes(null); setEnrolledUser(null); setError(""); setBusy(false); setPreparing(false); setDevice(false); setRecovering(false); setStatus(null); }; clear(); const invalidate = () => { scope.abort(); clear(); }; window.addEventListener(UNAUTHORIZED_EVENT, invalidate); window.addEventListener("aios:signed-out", invalidate); return () => { scope.abort(); window.removeEventListener(UNAUTHORIZED_EVENT, invalidate); window.removeEventListener("aios:signed-out", invalidate); }; }, [gateUsername, gatePassword]); useEffect(() => { if (gate) return; let current = true; const request = requestScope.current?.signal; setLoading(true); setError(""); void mfaStatus().then((next) => { if (!current || !request || request.aborted) return; setStatus(next); setLoading(false); if (!next) setError("Security status could not be loaded."); }); return () => { current = false; }; }, [gate, reload]); // Scalar dependencies keep a parent re-render from replacing the candidate. // Starting setup is read-only; ignore a late response after Back or a retry. useEffect(() => { if (gateUsername === undefined || gatePassword === undefined) return; let current = true; const request = requestScope.current?.signal; heading.current?.focus(); setPreparing(true); setSetup(null); setCode(""); setError(""); void mfaEnrollStart(gateUsername, gatePassword).then((result) => { if (!current || !request || request.aborted) return; setPreparing(false); if (result.ok === false) setError(result.message); else setSetup(result); }); return () => { current = false; }; }, [gateUsername, gatePassword, setupRetry]); // Lock BEFORE issuing codes, not only after receiving them: closing Settings // during the POST would throw away its only clear response. A native modal // makes the rail, close button and backdrop inert without changing the parent. // The shared Escape arbiter stops Settings' older window listener as well. useEscapeClose(busy, () => setError("Wait for your recovery codes before leaving.")); useEffect(() => { if (!locked) return; const node = dialog.current; if (!node) return; node.showModal(); return () => { node.close(); (passwordField.current ?? recoveryAction.current)?.focus(); }; }, [locked]); // Retry focus follows the busy dialog's password focus restoration. useEffect(() => { if (locked || preparing || !setup || !focusCodeOnRetry.current) return; focusCodeOnRetry.current = false; enrolForm.current?.querySelector("#security-enrol-code")?.focus(); }, [locked, preparing, setup]); async function generate(event: FormEvent) { event.preventDefault(); const request = requestScope.current?.signal; if (!request || request.aborted) return; if (flight.current || codes || !status?.enrolled || !password) return; flight.current = true; setBusy(true); setError(""); const result = await regenerateRecoveryCodes(password); if (request.aborted) return; // No password survives a write attempt. The response is the new set only; // do not re-read or cache it, and do not offer generation while it is shown. setPassword(""); if (result.ok === false) { setError(""); showRefusal(result.message); } else { setCodes(result.recoveryCodes); setStatus((previous) => previous ? { ...previous, recoveryCodesRemaining: result.recoveryCodes.length } : null); } flight.current = false; setBusy(false); } async function enrol(event: FormEvent) { event.preventDefault(); const request = requestScope.current?.signal; if (!request || request.aborted) return; if (flight.current || locked || preparing) return; if (!setup) { if (gate) { setSetupRetry((value) => value + 1); return; } if (!status?.enrolled || !password) return; flight.current = true; setPreparing(true); setError(""); try { const result = await startDevice(password); if (request.aborted) return; if (result.ok === false) { setError(""); showRefusal(result.message); setPassword(""); } else setSetup(result); } finally { if (!request.aborted) { flight.current = false; setPreparing(false); } } return; } if (!/^[0-9]{6}$/.test(code) || (!gate && (!status?.enrolled || !password))) return; flight.current = true; setBusy(true); setError(""); try { const result: { ok: true; user?: SessionUser; recoveryCodes: string[] } | AuthFailure = gate ? await mfaEnrollConfirm(gate.username, gate.password, setup.secret, code) : await confirmDevice(password, setup.secret, code); if (request.aborted) return; if (result.ok === false) { focusCodeOnRetry.current = true; if (gate) setError(result.message); else { setError(""); showRefusal(result.message); } } else { // A cookie exists only now. The frame still waits for the show-once acknowledgement. if (result.user) setEnrolledUser(result.user); setCodes(result.recoveryCodes); setSetup(null); setDevice(false); } } finally { if (!request.aborted) { setPassword(""); setCode(""); flight.current = false; setBusy(false); } } } const enrollmentForm = (gate || device) && !locked ? (
{!gate ? ( <>

A new device replaces your recovery codes and signs out your other sessions.

{ setPassword(event.target.value); setError(""); }} /> ) : null} {setup ? ( <> {/* The in-app encoder adds no dependency or external QR service. Keep manual setup available even when the QR cannot be drawn. */}

Type this setup code into any authenticator app.

{setup.issuer} setup code {setup.secret.match(/.{1,4}/g)?.join(" ")}
Authenticator setup link {setup.otpauthUri}
{ setCode(value); setError(""); }} invalid={Boolean(error)} describedBy="security-message" /> ) : preparing ? : null} {gate ? : null} ) : null; return (

Security

{gate ? <>

Two-step sign-in is required before the rest of the app opens.

{enrollmentForm} :

Two-step sign-in

{status && !status.enrolled ? "Sign in again to set up your authenticator app" : "Use an authenticator app to protect your account"}

{loading ? : status ?

{status.enrolled ? "On" : "Not set up"} {status.enrolled && status.enrolledAt ? <> · Since : null}

:
Security status could not be loaded.
} {device ?
{enrollmentForm}
: null}

Recovery codes

Use a saved code if you lose your authenticator

{loading ? : status?.enrolled ?

{status.recoveryCodesRemaining === 0 ? "No recovery codes left" : `${status.recoveryCodesRemaining} codes left`}

:

{status ? "Set up two-step sign-in to use recovery codes" : "Recovery code status is unavailable"}

} {recovering && !locked ?

New codes replace your old codes and sign out your other sessions.

{ setPassword(event.target.value); setError(""); }} />
: null}
}

{locked || (!gate && !status) ? "" : error}

{!gate ? : null} {/* R15/C12's explicit acknowledgement is the exception to ordinary dismissible dialogs. Native cancel is prevented, outside clicks have no close handler, and there is no close control or method=dialog form. */} {locked ? ( event.preventDefault()}>

Recovery codes

{codes ? ( { if (gate) { if (!enrolledUser) return; gate.onEnrolled(enrolledUser, codes); setEnrolledUser(null); setCodes(null); return; } setCodes(null); setError(""); setRecovering(false); // Count only, independently re-read after acknowledgement. setReload((value) => value + 1); }} /> ) : ( <>

Generating your recovery codes…

)}

{error}

) : null}
); }