Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

fix(web): reuse SDK sessions and forward auth cookies (#950)

Gener42dfd725b945
diff --git a/src/web/src/app/api/ws/token/route.session.test.ts b/src/web/src/app/api/ws/token/route.session.test.ts
new file mode 100644
index 000000000..1bba885de
--- /dev/null
+++ b/src/web/src/app/api/ws/token/route.session.test.ts
@@ -0,0 +1,138 @@
+import { createHmac } from "node:crypto"
+import { readFileSync } from "node:fs"
+import { DatabaseSync } from "node:sqlite"
+import { NextRequest } from "next/server"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import { getAuth } from "@/lib/auth"
+import { authResponseCookies } from "@/lib/auth-response-cookies"
+
+const environment = vi.hoisted(() => ({ current: {} as Env }))
+vi.mock("@opennextjs/cloudflare", () => ({ getCloudflareContext: () => ({ env: environment.current }) }))
+import { GET } from "./route"
+
+const secret = "fixture-only-ws-cookie-session-secret-192"
+const token = "fixture-only-ws-session-token-192"
+let database: DatabaseSync
+let now: number
+let version = 0
+
+beforeEach(() => {
+ now = Date.now()
+ database = new DatabaseSync(":memory:")
+ database.exec(`CREATE TABLE user (id TEXT PRIMARY KEY, name TEXT, email TEXT, emailVerified INTEGER, image TEXT, createdAt INTEGER, updatedAt INTEGER, discriminator TEXT, isBot INTEGER, deletedAt TEXT);
+ CREATE TABLE session (id TEXT PRIMARY KEY, token TEXT, userId TEXT, expiresAt INTEGER, createdAt INTEGER, updatedAt INTEGER, ipAddress TEXT, userAgent TEXT);`)
+ database.exec(readFileSync(new URL("../../../../../migrations/0001_schema.sql", import.meta.url), "utf8"))
+ database.exec(readFileSync(new URL("../../../../../migrations/0035_device_code_table.sql", import.meta.url), "utf8"))
+ database.prepare("INSERT INTO user VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")
+ .run("viewer-192", "Fixture", "[email protected]", 1, null, new Date(now).toISOString(), new Date(now).toISOString(), "0001", 0, null)
+ database.prepare("INSERT INTO session VALUES (?, ?, ?, ?, ?, ?, ?, ?)")
+ .run("session-192", token, "viewer-192", new Date(now + 30 * 86_400_000).toISOString(), new Date(now).toISOString(), new Date(now).toISOString(), null, null)
+ environment.current = {
+ DB: database,
+ NODE_ENV: "production",
+ BETTER_AUTH_URL: "https://fixture.test",
+ BETTER_AUTH_SECRET: secret,
+ CF_VERSION_METADATA: { id: `fixture-ws-192-${++version}`, tag: "fixture", timestamp: new Date(now).toISOString() },
+ } as unknown as Env
+ return () => { vi.restoreAllMocks(); database.close() }
+})
+
+async function sessionFixture() {
+ const auth = getAuth(environment.current)
+ const context = await auth.$context
+ const signed = encodeURIComponent(token + "." + createHmac("sha256", secret).update(token).digest("base64"))
+ const headers = new Headers({ Cookie: `${context.authCookies.sessionToken.name}=${signed}` })
+ const lookup = context.internalAdapter.findSession.bind(context.internalAdapter)
+ return { auth, context, headers, lookup, find: vi.spyOn(context.internalAdapter, "findSession") }
+}
+
+function nextHeaders(headers: Headers, response: Response) {
+ const forwarded = authResponseCookies(new NextRequest("https://fixture.test/api/ws/token", { headers }), response.headers)
+ const cookie = forwarded.headers.get("x-middleware-request-cookie")
+ return cookie === null ? new Headers(headers) : new Headers({ Cookie: cookie })
+}
+
+function request(headers: Headers, refresh = false) {
+ return new NextRequest(`https://fixture.test/api/ws/token${refresh ? "?refresh=1" : ""}`, { headers })
+}
+
+describe("real token-route session cookie roundtrip", () => {
+ it("returns the expired-cache refresh and restores the next-request fast path while the omitted-cookie control repeats storage", async () => {
+ const fixture = await sessionFixture()
+ expect(fixture.context.options.session?.cookieCache?.maxAge).toBe(300)
+ const initial = await GET(request(fixture.headers))
+ expect(initial.status).toBe(200)
+ expect(await initial.json()).toMatchObject({ userId: "viewer-192", token })
+ expect(fixture.find).toHaveBeenCalledOnce()
+ expect(initial.headers.getSetCookie().some(value => value.startsWith(fixture.context.authCookies.sessionData.name + "=") && /max-age=300/i.test(value))).toBe(true)
+ const cached = nextHeaders(fixture.headers, initial)
+ fixture.find.mockClear()
+ expect((await GET(request(cached))).status).toBe(200)
+ expect(fixture.find).not.toHaveBeenCalled()
+ vi.spyOn(Date, "now").mockReturnValue(now + 301_000)
+ const refresh = await GET(request(cached))
+ expect(refresh.status).toBe(200)
+ expect(fixture.find).toHaveBeenCalledOnce()
+ expect(refresh.headers.getSetCookie().some(value => /max-age=300/i.test(value))).toBe(true)
+ const omitted = await GET(request(cached))
+ expect(omitted.status).toBe(200)
+ expect(fixture.find).toHaveBeenCalledTimes(2)
+ const recovered = await GET(request(nextHeaders(cached, refresh)))
+ expect(recovered.status).toBe(200)
+ expect(await recovered.json()).toMatchObject({ userId: "viewer-192", token })
+ expect(fixture.find).toHaveBeenCalledTimes(2)
+ })
+
+ it("preserves the ordinary signed-cache contract but clears a revoked session through one authoritative refresh", async () => {
+ const fixture = await sessionFixture()
+ const initial = await GET(request(fixture.headers))
+ const cached = nextHeaders(fixture.headers, initial)
+ database.prepare("DELETE FROM session WHERE token = ?").run(token)
+ fixture.find.mockClear()
+ expect((await GET(request(cached))).status).toBe(200)
+ expect(fixture.find).not.toHaveBeenCalled()
+ const denied = await GET(request(cached, true))
+ expect(denied.status).toBe(401)
+ expect(await denied.text()).toBe("Unauthorized")
+ expect(fixture.find).toHaveBeenCalledOnce()
+ const deleted = denied.headers.getSetCookie()
+ expect(deleted.some(value => value.startsWith(fixture.context.authCookies.sessionToken.name + "=") && /max-age=0/i.test(value))).toBe(true)
+ expect(deleted.some(value => value.startsWith(fixture.context.authCookies.sessionData.name + "=") && /max-age=0/i.test(value))).toBe(true)
+ const cleared = nextHeaders(cached, denied)
+ expect(new NextRequest("https://fixture.test", { headers: cleared }).cookies.has(fixture.context.authCookies.sessionToken.name)).toBe(false)
+ expect((await GET(request(cleared))).status).toBe(401)
+ expect(fixture.find).toHaveBeenCalledOnce()
+ })
+
+ it("clears an actually expired stored session on the null response path", async () => {
+ const fixture = await sessionFixture()
+ database.prepare("UPDATE session SET expiresAt = ? WHERE token = ?").run(new Date(now - 1).toISOString(), token)
+ const denied = await GET(request(fixture.headers))
+ expect(denied.status).toBe(401)
+ expect(fixture.find).toHaveBeenCalledOnce()
+ expect(denied.headers.getSetCookie().some(value => value.startsWith(fixture.context.authCookies.sessionToken.name + "=") && /max-age=0/i.test(value))).toBe(true)
+ expect((await GET(request(nextHeaders(fixture.headers, denied)))).status).toBe(401)
+ expect(fixture.find).toHaveBeenCalledOnce()
+ })
+
+ it("forwards the real SDK error and deletion cookies when a stored session disappears between lookup and refresh", async () => {
+ const fixture = await sessionFixture()
+ database.prepare("UPDATE session SET expiresAt = ?, updatedAt = ? WHERE token = ?")
+ .run(new Date(now + 28 * 86_400_000).toISOString(), new Date(now - 2 * 86_400_000).toISOString(), token)
+ fixture.find.mockImplementationOnce(async (...args) => {
+ const current = await fixture.lookup(...args)
+ database.prepare("DELETE FROM session WHERE token = ?").run(token)
+ return current
+ })
+ const update = vi.spyOn(fixture.context.internalAdapter, "updateSession")
+ const denied = await GET(request(fixture.headers))
+ expect(denied.status).toBe(401)
+ expect(await denied.json()).toMatchObject({ code: "FAILED_TO_GET_SESSION" })
+ expect(fixture.find).toHaveBeenCalledOnce()
+ expect(update).toHaveBeenCalledOnce()
+ expect(denied.headers.getSetCookie().some(value => value.startsWith(fixture.context.authCookies.sessionToken.name + "=") && /max-age=0/i.test(value))).toBe(true)
+ expect(denied.headers.getSetCookie().some(value => value.startsWith(fixture.context.authCookies.sessionData.name + "=") && /max-age=0/i.test(value))).toBe(true)
+ expect((await GET(request(nextHeaders(fixture.headers, denied)))).status).toBe(401)
+ expect(fixture.find).toHaveBeenCalledOnce()
+ })
+})
diff --git a/src/web/src/app/api/ws/token/route.test.ts b/src/web/src/app/api/ws/token/route.test.ts
index e8c378b68..6ea98d757 100644
--- a/src/web/src/app/api/ws/token/route.test.ts
+++ b/src/web/src/app/api/ws/token/route.test.ts
@@ -2,6 +2,7 @@ import { describe, it, expect, vi, beforeEach } from "vitest"
import { NextRequest } from "next/server"
const mockGetSession = vi.fn()
+const mockEnv = vi.hoisted(() => ({ current: {} as Record<string, unknown> }))
vi.mock("@opennextjs/cloudflare", () => ({
getCloudflareContext: vi.fn(async () => ({ env: {} })),
@@ -14,7 +15,7 @@ vi.mock("@/lib/auth", () => ({
}))
vi.mock("@/lib/middleware/env", () => ({
- withEnv: vi.fn((handler: any) => async (req: any, ctx?: any) => handler(req, ctx ?? { env: {} })),
+ withEnv: vi.fn((handler: any) => async (req: any, ctx?: any) => handler(req, ctx ?? { env: mockEnv.current })),
}))
import { GET } from "./route"
@@ -22,23 +23,79 @@ import { GET } from "./route"
describe("GET /api/ws/token", () => {
beforeEach(() => {
vi.clearAllMocks()
+ mockEnv.current = {}
})
it("returns 401 when there is no session", async () => {
- mockGetSession.mockResolvedValue(null)
+ mockGetSession.mockResolvedValue(Response.json(null))
const res = await GET(new NextRequest("http://localhost/api/ws/token"))
expect(res.status).toBe(401)
})
it("returns userId and session token for an authenticated caller", async () => {
- mockGetSession.mockResolvedValue({
+ mockGetSession.mockResolvedValue(Response.json({
user: { id: "u_1" },
session: { token: "sess_tok" },
- })
+ }))
const res = await GET(new NextRequest("http://localhost/api/ws/token"))
expect(res.status).toBe(200)
const body = await res.json()
expect(body.userId).toBe("u_1")
expect(body.token).toBe("sess_tok")
})
+
+ it("requests the native SDK response with the original request headers", async () => {
+ mockGetSession.mockResolvedValue(Response.json(null))
+ const request = new NextRequest("http://localhost/api/ws/token", { headers: { Cookie: "fixture=signed" } })
+ await GET(request)
+ expect(mockGetSession).toHaveBeenCalledExactlyOnceWith({ headers: request.headers, asResponse: true })
+ })
+
+ it.each(["", "?refresh=0", "?refresh=true"])("keeps the ordinary cache path for %s", async (query) => {
+ mockGetSession.mockResolvedValue(Response.json(null))
+ const request = new NextRequest(`http://localhost/api/ws/token${query}`)
+ await GET(request)
+ expect(mockGetSession).toHaveBeenCalledExactlyOnceWith({ headers: request.headers, asResponse: true })
+ })
+
+ it("requests an authoritative SDK lookup only for refresh=1", async () => {
+ mockGetSession.mockResolvedValue(Response.json(null))
+ const request = new NextRequest("http://localhost/api/ws/token?refresh=1")
+ await GET(request)
+ expect(mockGetSession).toHaveBeenCalledExactlyOnceWith({ headers: request.headers, asResponse: true, query: { disableCookieCache: true } })
+ })
+
+ it.each([true, false])("forwards every refresh/chunk/deletion cookie with authenticated=%s", async (authenticated) => {
+ const headers = new Headers()
+ for (const value of [
+ "cache.0=updated; HttpOnly; Path=/; Max-Age=300",
+ "cache.1=; HttpOnly; Path=/; Max-Age=0",
+ "old=; HttpOnly; Path=/; Expires=Thu, 01 Jan 1970 00:00:00 GMT",
+ ]) headers.append("Set-Cookie", value)
+ mockGetSession.mockResolvedValue(Response.json(authenticated ? { user: { id: "u_1" }, session: { token: "sess_tok" } } : null, { headers }))
+ const result = await GET(new NextRequest("http://localhost/api/ws/token"))
+ expect(result.status).toBe(authenticated ? 200 : 401)
+ expect(result.headers.getSetCookie()).toEqual(headers.getSetCookie())
+ if (!authenticated) expect(await result.text()).toBe("Unauthorized")
+ })
+
+ it.each([401, 403, 500])("returns the SDK%s response with its original error body and clear cookies", async (status) => {
+ const headers = new Headers()
+ headers.append("Set-Cookie", "session=; HttpOnly; Path=/; Max-Age=0")
+ headers.append("Set-Cookie", "cache=; HttpOnly; Path=/; Expires=Thu, 01 Jan 1970 00:00:00 GMT")
+ const response = Response.json({ code: "FIXTURE_AUTH_ERROR", message: "fixture response" }, { status, headers })
+ mockGetSession.mockResolvedValue(response)
+ const result = await GET(new NextRequest("http://localhost/api/ws/token"))
+ expect(result).toBe(response)
+ expect(result.status).toBe(status)
+ expect(result.headers.getSetCookie()).toEqual(headers.getSetCookie())
+ expect(await result.json()).toEqual({ code: "FIXTURE_AUTH_ERROR", message: "fixture response" })
+ })
+
+ it("preserves configured local port discovery", async () => {
+ mockEnv.current = { DEV_WS_DO_URL: "ws://localhost:9123" }
+ mockGetSession.mockResolvedValue(Response.json({ user: { id: "u_1" }, session: { token: "sess_tok" } }))
+ const response = await GET(new NextRequest("http://localhost/api/ws/token"))
+ expect(await response.json()).toEqual({ userId: "u_1", token: "sess_tok", wsPort: 9123 })
+ })
})
diff --git a/src/web/src/app/api/ws/token/route.ts b/src/web/src/app/api/ws/token/route.ts
index a4def4a62..a3c863c1b 100644
--- a/src/web/src/app/api/ws/token/route.ts
+++ b/src/web/src/app/api/ws/token/route.ts
@@ -5,8 +5,18 @@ import { withEnv } from "@/lib/middleware/env"
export const GET = withEnv(async (req: NextRequest, ctx) => {
const auth = getAuth(ctx.env)
- const session = await auth.api.getSession({ headers: req.headers })
- if (!session) return new Response("Unauthorized", { status: 401 })
+ const authResponse = await auth.api.getSession({
+ headers: req.headers,
+ asResponse: true,
+ ...(req.nextUrl.searchParams.get("refresh") === "1" && { query: { disableCookieCache: true } }),
+ })
+ if (!authResponse.ok) return authResponse
+ const session = await authResponse.json() as typeof auth.$Infer.Session | null
+ if (!session) {
+ const response = new Response("Unauthorized", { status: 401 })
+ for (const cookie of authResponse.headers.getSetCookie()) response.headers.append("Set-Cookie", cookie)
+ return response
+ }
const wsDoUrl = (ctx.env as unknown as Record<string, unknown>).DEV_WS_DO_URL as string | undefined
let wsPort: number | undefined
@@ -14,9 +24,11 @@ export const GET = withEnv(async (req: NextRequest, ctx) => {
wsPort = new URL(wsDoUrl || DEV_WS_DO_URL).port ? Number(new URL(wsDoUrl || DEV_WS_DO_URL).port) : undefined
} catch {}
- return Response.json({
+ const response = Response.json({
userId: session.user.id,
token: session.session.token,
...(wsPort && { wsPort }),
})
+ for (const cookie of authResponse.headers.getSetCookie()) response.headers.append("Set-Cookie", cookie)
+ return response
});
diff --git a/src/web/src/hooks/community/use-community-ws.ts b/src/web/src/hooks/community/use-community-ws.ts
index 0450648b1..38f5f4767 100644
--- a/src/web/src/hooks/community/use-community-ws.ts
+++ b/src/web/src/hooks/community/use-community-ws.ts
@@ -545,6 +545,7 @@ export function useCommunityWs(options?: UseCommunityWsOptions): void {
return reconcileFocusedCommunityMessages(queryClient)
}, [queryClient, runtime.ws, viewerUserId])
const { send, reconnectNow } = useUserWs(handleMessage, {
+ viewerUserId,
communityContract: options?.communityContract,
onReconnect: handleReconnect,
onDisconnect: runtime.ws.actions.markAccessDisconnected,
diff --git a/src/web/src/lib/use-user-ws.session.dom.test.tsx b/src/web/src/lib/use-user-ws.session.dom.test.tsx
new file mode 100644
index 000000000..23d86d0ca
--- /dev/null
+++ b/src/web/src/lib/use-user-ws.session.dom.test.tsx
@@ -0,0 +1,265 @@
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import { act, renderHook, waitFor } from "@/test/react-dom-harness"
+
+const backend = vi.hoisted(() => { const fetch = vi.fn(); vi.stubGlobal("fetch", fetch); return fetch })
+vi.mock("@/lib/analytics", () => ({
+ trackCommunityWsAuthFailure: vi.fn(), trackCommunityWsFrameDropped: vi.fn(),
+ trackCommunityWsLifecycleClose: vi.fn(), trackCommunityWsLifecycleRecovery: vi.fn(),
+ trackCommunityWsLifecycleStage: vi.fn(), trackCommunityWsRetryScheduled: vi.fn(),
+}))
+import { authClient } from "./auth-client"
+import { useUserWs } from "./use-user-ws"
+
+class SessionSocket {
+ static CONNECTING = 0
+ static OPEN = 1
+ static CLOSING = 2
+ static CLOSED = 3
+ static instances: SessionSocket[] = []
+ readyState = SessionSocket.CONNECTING
+ sent: string[] = []
+ onopen: (() => void) | null = null
+ onmessage: ((event: { data: string }) => void) | null = null
+ onclose: ((event: { code: number; reason: string; wasClean: boolean }) => void) | null = null
+ onerror: (() => void) | null = null
+ constructor(readonly url: string) { SessionSocket.instances.push(this) }
+ send(value: string) { this.sent.push(value) }
+ close(code = 1000, reason = "") {
+ if (this.readyState === SessionSocket.CLOSED) return
+ this.readyState = SessionSocket.CLOSED
+ this.onclose?.({ code, reason, wasClean: true })
+ }
+ open() { this.readyState = SessionSocket.OPEN; this.onopen?.() }
+ message(value: unknown) { this.onmessage?.({ data: JSON.stringify(value) }) }
+ authenticate() { this.open(); this.message({ type: "auth.ok", communityContract: 2 }) }
+ rejected() { this.readyState = SessionSocket.CLOSED; this.onclose?.({ code: 1008, reason: "Unauthorized", wasClean: false }) }
+}
+
+type SessionIdentity = { userId: string; id: string; token: string }
+type HeldResponse = { response: Response; release: (response: Response) => void; signal: AbortSignal | null | undefined }
+let selected: SessionIdentity | null
+let sessionError: boolean
+let holdTokens: boolean
+let held: HeldResponse[]
+let sessionRequests: number
+let tokenPaths: string[]
+
+function sessionPayload() {
+ if (!selected) return null
+ const now = new Date().toISOString()
+ return {
+ user: { id: selected.userId, name: selected.userId, email: selected.userId + "@example.test", emailVerified: true, image: null, createdAt: now, updatedAt: now },
+ session: { id: selected.id, token: selected.token, userId: selected.userId, expiresAt: new Date(Date.now() + 3_600_000).toISOString(), createdAt: now, updatedAt: now },
+ }
+}
+
+beforeEach(async () => {
+ selected = { userId: "account-a", id: "session-a-1", token: "fixture-sdk-a-1" }
+ sessionError = false
+ holdTokens = false
+ held = []
+ sessionRequests = 0
+ tokenPaths = []
+ SessionSocket.instances = []
+ vi.stubGlobal("WebSocket", SessionSocket)
+ vi.stubGlobal("fetch", backend)
+ backend.mockReset()
+ backend.mockImplementation(async (input: string | URL | Request, init?: RequestInit) => {
+ const url = new URL(typeof input === "string" ? input : input instanceof URL ? input.href : input.url, window.location.origin)
+ if (url.pathname.endsWith("/get-session")) {
+ sessionRequests++
+ return sessionError ? Response.json({ message: "fixture session unavailable" }, { status: 500 }) : Response.json(sessionPayload())
+ }
+ if (url.pathname.endsWith("/sign-in/email")) return Response.json({ redirect: false, user: sessionPayload()!.user, token: selected!.token })
+ if (url.pathname.endsWith("/sign-out")) { selected = null; return Response.json({ success: true }) }
+ if (url.pathname === "/api/ws/token") {
+ tokenPaths.push(url.pathname + url.search)
+ const response = selected ? Response.json({ userId: selected.userId, token: "fixture-http-" + selected.id, wsPort: 9123 }) : new Response("Unauthorized", { status: 401 })
+ if (!holdTokens) return response
+ return new Promise<Response>(release => held.push({ response, release, signal: init?.signal }))
+ }
+ throw new Error("Unexpected native SDK fixture path " + url.pathname)
+ })
+ await act(async () => {
+ await authClient.$store.atoms.session.get().refetch()
+ await new Promise(resolve => setTimeout(resolve, 0))
+ })
+ expect(authClient.$store.atoms.session.get()).toMatchObject({ isPending: false, error: null, data: { user: { id: "account-a" } } })
+ expect(authClient.$store.atoms.session.get().data?.session.expiresAt).toBeInstanceOf(Date)
+ return async () => {
+ for (const value of held) value.release(value.response)
+ await act(async () => { await new Promise(resolve => setTimeout(resolve, 1_100)) })
+ vi.restoreAllMocks()
+ vi.unstubAllGlobals()
+ }
+})
+
+function mount(onMessage = vi.fn()) {
+ return renderHook(({ viewerUserId }) => useUserWs(onMessage, {
+ viewerUserId, communityContract: 2, requestDaemonStatusOnAuth: false,
+ }), { initialProps: { viewerUserId: "account-a" } })
+}
+
+async function authenticateInitial() {
+ await waitFor(() => expect(SessionSocket.instances).toHaveLength(1))
+ act(() => SessionSocket.instances[0]!.authenticate())
+}
+
+function authTokens(socket: SessionSocket) {
+ return socket.sent.flatMap(value => {
+ const message = JSON.parse(value) as { type?: string; token?: string }
+ return message.type === "auth" ? [message.token] : []
+ })
+}
+
+describe("real BetterAuth SDK WebSocket ownership", () => {
+ it("uses the installed SDK parsed credential on reconnect while a bootstrap-only HTTP gate stays unused", async () => {
+ const view = mount()
+ await authenticateInitial()
+ expect(tokenPaths).toEqual(["/api/ws/token"])
+ holdTokens = true
+ act(() => view.result.current.reconnectNow())
+ await waitFor(() => expect(SessionSocket.instances).toHaveLength(2))
+ const replacement = SessionSocket.instances[1]!
+ act(() => replacement.authenticate())
+ expect(authTokens(replacement)).toEqual(["fixture-sdk-a-1"])
+ expect(tokenPaths).toEqual(["/api/ws/token"])
+ expect(held).toEqual([])
+ })
+
+ it("retires same-user session replacement through the public SDK sign-in lifecycle", async () => {
+ const onMessage = vi.fn()
+ mount(onMessage)
+ await authenticateInitial()
+ const original = SessionSocket.instances[0]!
+ selected = { userId: "account-a", id: "session-a-2", token: "fixture-sdk-a-2" }
+ await act(async () => { expect((await authClient.signIn.email({ email: "[email protected]", password: "fixture-only" })).error).toBeNull() })
+ await waitFor(() => expect(authClient.$store.atoms.session.get().data?.session.id).toBe("session-a-2"))
+ await waitFor(() => expect(SessionSocket.instances).toHaveLength(2))
+ expect(original.readyState).toBe(SessionSocket.CLOSED)
+ act(() => original.message({ type: "task.updated", taskId: "retired-a" }))
+ expect(onMessage).not.toHaveBeenCalled()
+ const replacement = SessionSocket.instances[1]!
+ act(() => replacement.authenticate())
+ expect(authTokens(replacement)).toEqual(["fixture-sdk-a-2"])
+ expect(tokenPaths).toEqual(["/api/ws/token"])
+ })
+
+ it("retires a late old HTTP response during an SDK account switch and bootstraps the new owner separately", async () => {
+ holdTokens = true
+ const onMessage = vi.fn()
+ const view = mount(onMessage)
+ await waitFor(() => expect(held).toHaveLength(1))
+ const original = held[0]!
+ selected = { userId: "account-b", id: "session-b-1", token: "fixture-sdk-b-1" }
+ await act(async () => { expect((await authClient.signIn.email({ email: "[email protected]", password: "fixture-only" })).error).toBeNull() })
+ await waitFor(() => expect(authClient.$store.atoms.session.get().data?.user.id).toBe("account-b"))
+ expect(original.signal?.aborted).toBe(true)
+ holdTokens = false
+ await act(async () => { original.release(original.response) })
+ expect(SessionSocket.instances).toEqual([])
+ view.rerender({ viewerUserId: "account-b" })
+ await waitFor(() => expect(SessionSocket.instances).toHaveLength(1))
+ const current = SessionSocket.instances[0]!
+ expect(new URL(current.url).searchParams.get("userId")).toBe("account-b")
+ act(() => { current.authenticate(); current.message({ type: "task.updated", taskId: "current-b" }) })
+ expect(authTokens(current)).toEqual(["fixture-http-session-b-1"])
+ expect(onMessage).toHaveBeenCalledOnce()
+ expect(onMessage.mock.calls[0]![0]).toMatchObject({ taskId: "current-b" })
+ expect(tokenPaths).toEqual(["/api/ws/token", "/api/ws/token"])
+ await act(async () => { expect((await authClient.signOut()).error).toBeNull() })
+ await waitFor(() => expect(authClient.$store.atoms.session.get().data).toBeNull())
+ expect(current.readyState).toBe(SessionSocket.CLOSED)
+ const sent = current.sent.length
+ act(() => { view.result.current.send({ type: "fixture-after-logout" }); current.message({ type: "task.updated", taskId: "retired-b" }) })
+ expect(current.sent).toHaveLength(sent)
+ expect(onMessage).toHaveBeenCalledOnce()
+ })
+
+ it("uses HTTP instead of retained SDK error data and cancels that fallback when the real SDK session changes", async () => {
+ const view = mount()
+ await authenticateInitial()
+ sessionError = true
+ await act(async () => { await authClient.$store.atoms.session.get().refetch() })
+ expect(authClient.$store.atoms.session.get().error).toBeTruthy()
+ expect(authClient.$store.atoms.session.get().data?.session.token).toBe("fixture-sdk-a-1")
+ holdTokens = true
+ act(() => view.result.current.reconnectNow())
+ await waitFor(() => expect(held).toHaveLength(1))
+ const old = held[0]!
+ sessionError = false
+ selected = { userId: "account-a", id: "session-a-2", token: "fixture-sdk-a-2" }
+ await act(async () => { expect((await authClient.signIn.email({ email: "[email protected]", password: "fixture-only" })).error).toBeNull() })
+ await waitFor(() => expect(authClient.$store.atoms.session.get().data?.session.id).toBe("session-a-2"))
+ expect(old.signal?.aborted).toBe(true)
+ await waitFor(() => expect(SessionSocket.instances).toHaveLength(2))
+ const current = SessionSocket.instances[1]!
+ act(() => current.authenticate())
+ await act(async () => { old.release(old.response) })
+ expect(SessionSocket.instances).toHaveLength(2)
+ expect(authTokens(current)).toEqual(["fixture-sdk-a-2"])
+ expect(tokenPaths).toEqual(["/api/ws/token", "/api/ws/token"])
+ })
+
+ it("performs one authoritative fallback and one native SDK refetch without a rejected-credential event loop", async () => {
+ const view = mount()
+ await authenticateInitial()
+ act(() => view.result.current.reconnectNow())
+ await waitFor(() => expect(SessionSocket.instances).toHaveLength(2))
+ act(() => { SessionSocket.instances[1]!.open(); SessionSocket.instances[1]!.rejected() })
+ await waitFor(() => expect(SessionSocket.instances).toHaveLength(3), { timeout: 3_000 })
+ expect(tokenPaths).toEqual(["/api/ws/token", "/api/ws/token?refresh=1"])
+ sessionError = true
+ const baseline = sessionRequests
+ await act(async () => { SessionSocket.instances[2]!.open(); SessionSocket.instances[2]!.rejected() })
+ await waitFor(() => expect(authClient.$store.atoms.session.get().error).toBeTruthy())
+ expect(sessionRequests).toBe(baseline + 1)
+ act(() => {
+ document.dispatchEvent(new Event("resume"))
+ document.dispatchEvent(new Event("resume"))
+ window.dispatchEvent(new PageTransitionEvent("pageshow", { persisted: true }))
+ })
+ await act(async () => { await new Promise(resolve => setTimeout(resolve, 1_100)) })
+ expect(SessionSocket.instances).toHaveLength(3)
+ expect(tokenPaths).toEqual(["/api/ws/token", "/api/ws/token?refresh=1"])
+ expect(sessionRequests).toBe(baseline + 1)
+ })
+
+ it("preempts remote-close backoff when the public SDK replaces same-user A1 with A2", async () => {
+ const view = mount()
+ await authenticateInitial()
+ act(() => view.result.current.reconnectNow())
+ await waitFor(() => expect(SessionSocket.instances).toHaveLength(2))
+ const original = SessionSocket.instances[1]!
+ act(() => original.authenticate())
+ expect(authTokens(original)).toEqual(["fixture-sdk-a-1"])
+ vi.spyOn(Math, "random").mockReturnValue(0.9)
+ act(() => original.close(1006, "fixture remote outage"))
+ selected = { userId: "account-a", id: "session-a-2", token: "fixture-sdk-a-2" }
+ await act(async () => { expect((await authClient.signIn.email({ email: "[email protected]", password: "fixture-only" })).error).toBeNull() })
+ await waitFor(() => expect(authClient.$store.atoms.session.get().data?.session.id).toBe("session-a-2"))
+ await waitFor(() => expect(SessionSocket.instances).toHaveLength(3))
+ const current = SessionSocket.instances[2]!
+ act(() => current.authenticate())
+ await act(async () => { await new Promise(resolve => setTimeout(resolve, 1_100)) })
+ expect(original.readyState).toBe(SessionSocket.CLOSED)
+ expect(SessionSocket.instances).toHaveLength(3)
+ expect(authTokens(current)).toEqual(["fixture-sdk-a-2"])
+ expect(tokenPaths).toEqual(["/api/ws/token"])
+ })
+
+ it("unsubscribes the installed SDK and fences old callbacks after a real React unmount", async () => {
+ const onMessage = vi.fn()
+ const view = mount(onMessage)
+ await authenticateInitial()
+ const old = SessionSocket.instances[0]!
+ view.unmount()
+ expect(old.readyState).toBe(SessionSocket.CLOSED)
+ selected = { userId: "account-a", id: "session-a-2", token: "fixture-sdk-a-2" }
+ await act(async () => { await authClient.$store.atoms.session.get().refetch() })
+ act(() => { old.open(); old.message({ type: "auth.ok", communityContract: 2 }); old.message({ type: "task.updated", taskId: "after-unmount" }) })
+ expect(onMessage).not.toHaveBeenCalled()
+ expect(SessionSocket.instances).toHaveLength(1)
+ expect(tokenPaths).toEqual(["/api/ws/token"])
+ })
+})
diff --git a/src/web/src/lib/use-user-ws.test.ts b/src/web/src/lib/use-user-ws.test.ts
index a95ad285b..36b6a58f7 100644
--- a/src/web/src/lib/use-user-ws.test.ts
+++ b/src/web/src/lib/use-user-ws.test.ts
@@ -14,6 +14,37 @@ import {
} from "@alook/shared"
import type { UseUserWsOptions } from "./use-user-ws"
+type TestSdkSession = {
+ data: { user: { id: string }; session?: { id: string; userId: string; token: string; expiresAt: Date } } | null
+ isPending: boolean
+ error: unknown
+}
+
+const mockSdkSession = vi.hoisted(() => {
+ let current: TestSdkSession = { data: null, isPending: true, error: null }
+ const listeners = new Set<(value: TestSdkSession, previous: TestSdkSession) => void>()
+ const refetch = vi.fn(async () => {})
+ return {
+ refetch,
+ get: () => ({ ...current, refetch }),
+ listen: (listener: (value: TestSdkSession, previous: TestSdkSession) => void) => {
+ listeners.add(listener)
+ return () => { listeners.delete(listener) }
+ },
+ set: (value: TestSdkSession) => {
+ const previous = current
+ current = value
+ for (const listener of listeners) listener(value, previous)
+ },
+ reset: () => {
+ current = { data: null, isPending: true, error: null }
+ listeners.clear()
+ refetch.mockClear()
+ },
+ }
+})
+vi.mock("@/lib/auth-client", () => ({ authClient: { $store: { atoms: { session: mockSdkSession } } } }))
+
const mockTrackCommunityWsLifecycleRecovery = vi.hoisted(() => vi.fn())
const mockTrackCommunityWsAuthFailure = vi.hoisted(() => vi.fn())
const mockTrackCommunityWsLifecycleClose = vi.hoisted(() => vi.fn())
@@ -196,6 +227,14 @@ function setupTokenFetch() {
})
}
+function sdkSession(userId = "user-1", id = "sdk-session-1", token = "current-sdk-token"): TestSdkSession {
+ return {
+ data: { user: { id: userId }, session: { id, userId, token, expiresAt: new Date(Date.now() + 3_600_000) } },
+ isPending: false,
+ error: null,
+ }
+}
+
function connectionPings(ws: MockWebSocket): Array<{ type: "connection.ping"; nonce: string }> {
return ws.sent.flatMap((value) => {
try {
@@ -229,6 +268,7 @@ function resetMockState() {
vi.stubGlobal("WebSocket", MockWebSocket)
MockWebSocket.instances = []
mockFetch.mockReset()
+ mockSdkSession.reset()
effectCleanup = null
refs = new Map()
refCounter = 0
@@ -270,6 +310,189 @@ describe("useUserWs", () => {
return mod
}
+ it("keeps bootstrap port discovery and authenticates a current SDK reconnect without another HTTP request", async () => {
+ mockSdkSession.set(sdkSession())
+ mockFetch.mockResolvedValue({ ok: true, json: async () => ({ userId: "user-1", token: "bootstrap-token", wsPort: 9123 }) })
+ await mountHook(vi.fn(), { viewerUserId: "user-1", communityContract: 2, requestDaemonStatusOnAuth: false })
+ const first = MockWebSocket.instances[0]!
+ first.simulateOpen()
+ first.simulateMessage({ type: "auth.ok", communityContract: 2 })
+ expect(mockFetch).toHaveBeenCalledOnce()
+ expect(first.sent).toEqual([JSON.stringify({ type: "auth", token: "bootstrap-token", communityContract: 2 })])
+ latestHookResult!.reconnectNow()
+ await flushPromises()
+ const replacement = MockWebSocket.instances[1]!
+ expect(replacement.url).toBe("ws://localhost:9123/api/ws/user?userId=user-1")
+ replacement.simulateOpen()
+ expect(replacement.sent).toEqual([JSON.stringify({ type: "auth", token: "current-sdk-token", communityContract: 2 })])
+ replacement.simulateMessage({ type: "auth.ok", communityContract: 2 })
+ expect(mockFetch).toHaveBeenCalledOnce()
+ })
+
+ it.each(["pending", "error", "missing", "missing-session", "empty-id", "session-owner", "expired", "invalid-expiry"])("falls back without admitting %s SDK credentials", async (state) => {
+ mockSdkSession.set(sdkSession())
+ setupTokenFetch()
+ await mountHook(vi.fn(), { viewerUserId: "user-1", requestDaemonStatusOnAuth: false })
+ const first = MockWebSocket.instances[0]!
+ first.simulateOpen()
+ first.simulateMessage({ type: "auth.ok" })
+ const value = sdkSession()
+ if (state === "pending") value.isPending = true
+ if (state === "error") value.error = new Error("session unavailable")
+ if (state === "missing") value.data!.session!.token = ""
+ if (state === "missing-session") value.data!.session = undefined
+ if (state === "empty-id") value.data!.session!.id = ""
+ if (state === "session-owner") value.data!.session!.userId = "user-2"
+ if (state === "expired") value.data!.session!.expiresAt = new Date(Date.now() - 1)
+ if (state === "invalid-expiry") value.data!.session!.expiresAt = new Date(Number.NaN)
+ mockSdkSession.set(value)
+ if (!["missing", "missing-session", "empty-id"].includes(state)) latestHookResult!.reconnectNow()
+ await flushPromises()
+ const replacement = MockWebSocket.instances.at(-1)!
+ replacement.simulateOpen()
+ expect(mockFetch.mock.calls.map(([url]) => url)).toEqual(["/api/ws/token", "/api/ws/token"])
+ expect(replacement.sent.some((frame) => JSON.parse(frame).token === "current-sdk-token")).toBe(false)
+ expect(replacement.sent.some((frame) => JSON.parse(frame).token === "tok-123")).toBe(true)
+ })
+
+ it("retires an old-owner token request and ignores its late response after a native SDK account change", async () => {
+ mockSdkSession.set(sdkSession())
+ const response = deferred<Response>()
+ mockFetch.mockReturnValue(response.promise)
+ await mountHook(vi.fn(), { viewerUserId: "user-1", requestDaemonStatusOnAuth: false })
+ const signal = mockFetch.mock.calls[0]![1].signal as AbortSignal
+ mockSdkSession.set(sdkSession("user-2", "sdk-session-2", "other-sdk-token"))
+ expect(signal.aborted).toBe(true)
+ response.resolve(Response.json({ userId: "user-1", token: "old-owner-token" }))
+ await flushPromises()
+ mockWindow.dispatch("focus")
+ await vi.advanceTimersByTimeAsync(60_000)
+ expect(MockWebSocket.instances).toEqual([])
+ expect(mockFetch).toHaveBeenCalledOnce()
+ expect(mockSdkSession.refetch).not.toHaveBeenCalled()
+ })
+
+ it("rejects a foreign HTTP identity before socket construction", async () => {
+ mockSdkSession.set(sdkSession())
+ mockFetch.mockResolvedValue(Response.json({ userId: "user-2", token: "foreign-fixture-token" }))
+ await mountHook(vi.fn(), { viewerUserId: "user-1", requestDaemonStatusOnAuth: false })
+ await vi.advanceTimersByTimeAsync(60_000)
+ expect(MockWebSocket.instances).toEqual([])
+ expect(mockFetch).toHaveBeenCalledOnce()
+ expect(mockSdkSession.refetch).toHaveBeenCalledOnce()
+ })
+
+ it.each([401, 403])("stops an HTTP%s credential sequence and refetches the native SDK at most once", async (status) => {
+ mockSdkSession.set(sdkSession())
+ mockFetch.mockResolvedValue({ ok: false, status })
+ await mountHook(vi.fn(), { viewerUserId: "user-1", requestDaemonStatusOnAuth: false })
+ mockDocument.dispatch("resume")
+ mockWindow.dispatch("focus")
+ await vi.advanceTimersByTimeAsync(60_000)
+ expect(mockFetch).toHaveBeenCalledOnce()
+ expect(mockSdkSession.refetch).toHaveBeenCalledExactlyOnceWith({ query: { disableCookieCache: true } })
+ expect(MockWebSocket.instances).toEqual([])
+ latestHookResult!.reconnectNow()
+ await flushPromises()
+ expect(mockFetch).toHaveBeenCalledTimes(2)
+ expect(mockSdkSession.refetch).toHaveBeenCalledTimes(2)
+ })
+
+ it("makes one authoritative fallback for a rejected SDK session and stops a fresh rejection until explicit Retry", async () => {
+ mockSdkSession.set(sdkSession())
+ setupTokenFetch()
+ await mountHook(vi.fn(), { viewerUserId: "user-1", requestDaemonStatusOnAuth: false })
+ const first = MockWebSocket.instances[0]!
+ first.simulateOpen()
+ first.simulateMessage({ type: "auth.ok" })
+ latestHookResult!.reconnectNow()
+ await flushPromises()
+ const sdk = MockWebSocket.instances[1]!
+ sdk.simulateOpen()
+ sdk.simulateClose(1008, "Unauthorized", false)
+ await vi.advanceTimersByTimeAsync(1_000)
+ expect(mockFetch.mock.calls.map(([url]) => url)).toEqual(["/api/ws/token", "/api/ws/token?refresh=1"])
+ const fallback = MockWebSocket.instances[2]!
+ fallback.simulateOpen()
+ fallback.simulateClose(1008, "Unauthorized", false)
+ mockDocument.dispatch("resume")
+ mockWindow.dispatch("focus")
+ await vi.advanceTimersByTimeAsync(60_000)
+ expect(mockFetch).toHaveBeenCalledTimes(2)
+ expect(MockWebSocket.instances).toHaveLength(3)
+ expect(mockSdkSession.refetch).toHaveBeenCalledOnce()
+ latestHookResult!.reconnectNow()
+ await flushPromises()
+ expect(mockFetch.mock.calls.map(([url]) => url)).toEqual(["/api/ws/token", "/api/ws/token?refresh=1", "/api/ws/token?refresh=1"])
+ })
+
+ it("handles a public SDK refetch rejection while keeping the credential sequence stopped", async () => {
+ mockSdkSession.set(sdkSession())
+ mockSdkSession.refetch.mockRejectedValueOnce(new Error("fixture SDK refetch exception"))
+ mockFetch.mockResolvedValue({ ok: false, status: 401 })
+ await mountHook(vi.fn(), { viewerUserId: "user-1", requestDaemonStatusOnAuth: false })
+ mockDocument.dispatch("resume")
+ mockWindow.dispatch("focus")
+ await vi.advanceTimersByTimeAsync(60_000)
+ expect(mockFetch).toHaveBeenCalledOnce()
+ expect(mockSdkSession.refetch).toHaveBeenCalledExactlyOnceWith({ query: { disableCookieCache: true } })
+ expect(MockWebSocket.instances).toEqual([])
+ })
+
+ it("does not repeat an authoritative read after a transient fallback failure", async () => {
+ mockSdkSession.set(sdkSession())
+ setupTokenFetch()
+ await mountHook(vi.fn(), { viewerUserId: "user-1", requestDaemonStatusOnAuth: false })
+ const first = MockWebSocket.instances[0]!
+ first.simulateOpen()
+ first.simulateMessage({ type: "auth.ok" })
+ latestHookResult!.reconnectNow()
+ await flushPromises()
+ mockFetch.mockRejectedValueOnce(new Error("fixture transport unavailable"))
+ const sdk = MockWebSocket.instances[1]!
+ sdk.simulateOpen()
+ sdk.simulateClose(1008, "Unauthorized", false)
+ await vi.advanceTimersByTimeAsync(4_000)
+ expect(mockFetch.mock.calls.map(([url]) => url)).toEqual(["/api/ws/token", "/api/ws/token?refresh=1", "/api/ws/token"])
+ })
+
+ it.each(["Unsupported community contract", "Invalid JSON", "Not authenticated"])("keeps protocol policy close %s out of credential refresh", async (reason) => {
+ mockSdkSession.set(sdkSession())
+ setupTokenFetch()
+ await mountHook(vi.fn(), { viewerUserId: "user-1", requestDaemonStatusOnAuth: false })
+ const first = MockWebSocket.instances[0]!
+ first.simulateOpen()
+ first.simulateMessage({ type: "auth.ok" })
+ latestHookResult!.reconnectNow()
+ await flushPromises()
+ const sdk = MockWebSocket.instances[1]!
+ sdk.simulateOpen()
+ sdk.simulateClose(1008, reason, false)
+ await vi.advanceTimersByTimeAsync(1_000)
+ expect(mockFetch).toHaveBeenCalledOnce()
+ expect(mockSdkSession.refetch).not.toHaveBeenCalled()
+ expect(mockTrackCommunityWsAuthFailure).toHaveBeenLastCalledWith({ failureClass: "unknown" })
+ })
+
+ it("does not refresh credentials after a server contract frame even with an Unauthorized close", async () => {
+ mockSdkSession.set(sdkSession())
+ setupTokenFetch()
+ await mountHook(vi.fn(), { viewerUserId: "user-1", requestDaemonStatusOnAuth: false })
+ const first = MockWebSocket.instances[0]!
+ first.simulateOpen()
+ first.simulateMessage({ type: "auth.ok" })
+ latestHookResult!.reconnectNow()
+ await flushPromises()
+ const sdk = MockWebSocket.instances[1]!
+ sdk.simulateOpen()
+ sdk.simulateMessage({ type: "auth.error", error: "Unsupported community contract" })
+ sdk.simulateClose(1008, "Unauthorized", false)
+ await vi.advanceTimersByTimeAsync(1_000)
+ expect(mockFetch).toHaveBeenCalledOnce()
+ expect(mockSdkSession.refetch).not.toHaveBeenCalled()
+ expect(mockTrackCommunityWsAuthFailure).toHaveBeenLastCalledWith({ failureClass: "unknown" })
+ })
+
it("requires protocol confirmation before a v2 batch reaches the callback", async () => {
setupTokenFetch()
const callback = vi.fn()
diff --git a/src/web/src/lib/use-user-ws.ts b/src/web/src/lib/use-user-ws.ts
index 03845a6da..aca4b55fa 100644
--- a/src/web/src/lib/use-user-ws.ts
+++ b/src/web/src/lib/use-user-ws.ts
@@ -32,6 +32,7 @@ import {
} from "@/lib/analytics"
import { isLocalServiceEnvironment, WS_DO_PORT_DEFAULT } from "@/lib/utils"
import { websocketUrl } from "@/lib/websocket-url"
+import { authClient } from "@/lib/auth-client"
const useLocalServices = isLocalServiceEnvironment()
const WS_RECONNECT_INIT = Number(process.env.NEXT_PUBLIC_WS_RECONNECT_DELAY_MS) || 1000
@@ -57,6 +58,37 @@ type PendingTokenAttempt = {
observationGeneration: number
}
+type CredentialRetry = {
+ rejectedSessionId: string | null
+ refreshUsed: boolean
+ stopped: boolean
+ refetchUsed: boolean
+}
+
+function currentSdkWsSession(viewerUserId: string | null | undefined) {
+ if (!viewerUserId) return
+ const current = authClient.$store.atoms.session.get()
+ const data = current.data
+ const session = data?.session
+ if (current.isPending || current.error || data?.user?.id !== viewerUserId
+ || !session || session.userId !== viewerUserId || !session.id || !session.token) return
+ const expiresAt = session.expiresAt
+ if (!(expiresAt instanceof Date) || !Number.isFinite(expiresAt.getTime())
+ || expiresAt.getTime() <= Date.now()) return
+ return data
+}
+
+function isCurrentWsAccount(viewerUserId: string | null | undefined) {
+ if (viewerUserId === undefined) return true
+ if (!viewerUserId) return false
+ const current = authClient.$store.atoms.session.get()
+ return current.isPending || Boolean(current.error) || current.data?.user?.id === viewerUserId
+}
+
+function isWsCredentialRejection(event?: Pick<CloseEvent, "code" | "reason">) {
+ return event?.code === 1008 && event.reason === "Unauthorized"
+}
+
function isPageHidden(): boolean {
return typeof document !== "undefined" && document.visibilityState === "hidden"
}
@@ -129,6 +161,7 @@ export type WsMessageIncoming = WsMessage & { [key: string]: unknown }
export type UserWsConnectionPhase = "authenticated" | "reconnecting" | "suspended"
export type UseUserWsOptions = {
+ viewerUserId?: string | null
communityContract?: CommunityContract
onReconnect?: (info: { reconnectDurationMs: number }) => void | Promise<void>
onDisconnect?: () => void | Promise<void>
@@ -175,6 +208,12 @@ export function useUserWs(
onMessage: (msg: WsMessageIncoming, assertCurrent?: () => void, communityContract?: CommunityContract) => void | Promise<void>,
options?: UseUserWsOptions,
): { send: (msg: object) => void; reconnectNow: () => void } {
+ const viewerUserId = options?.viewerUserId
+ const previousViewerRef = useRef(viewerUserId)
+ const wsPortRef = useRef(WS_DO_PORT_DEFAULT)
+ const credentialRetryRef = useRef<CredentialRetry>({
+ rejectedSessionId: null, refreshUsed: false, stopped: false, refetchUsed: false,
+ })
const wsRef = useRef<WebSocket | null>(null)
const reconnectDelay = useRef(WS_RECONNECT_INIT)
const reconnectAttemptRef = useRef(0)
@@ -255,7 +294,8 @@ export function useUserWs(
const ownsConnection = useCallback((ws: WebSocket, generation: number) => (
ws === wsRef.current && generation === connectionGenerationRef.current
- ), [])
+ && isCurrentWsAccount(viewerUserId)
+ ), [viewerUserId])
const ownsAuthenticatedConnection = useCallback((ws: WebSocket, generation: number) => (
ownsConnection(ws, generation)
@@ -390,6 +430,17 @@ export function useUserWs(
if (ws) closeSocket(ws, initiator)
}, [clearConnectionValidation, closeSocket, stopHeartbeat])
+ const stopCredentialRetry = useCallback(() => {
+ const retry = credentialRetryRef.current
+ retry.stopped = true
+ retireSocket(true, "auth-failure")
+ if (viewerUserId === undefined || retry.refetchUsed) return
+ retry.refetchUsed = true
+ void authClient.$store.atoms.session.get().refetch({ query: { disableCookieCache: true } }).catch(() => {
+ console.warn("[ws] session refetch failed")
+ })
+ }, [retireSocket, viewerUserId])
+
const failConnectionValidation = useCallback((
ws: WebSocket,
generation: number,
@@ -457,6 +508,7 @@ export function useUserWs(
const scheduleReconnect = useCallback((generation: number) => {
if (generation !== connectionGenerationRef.current) return
+ if (credentialRetryRef.current.stopped || !isCurrentWsAccount(viewerUserId)) return
if (isPageHidden() || isOffline() || frozenRef.current) return
if (reconnectTimerRef.current !== null) {
clearTimeout(reconnectTimerRef.current)
@@ -479,9 +531,10 @@ export function useUserWs(
) return
void connectRef.current?.()
}, delayMs)
- }, [isOffline])
+ }, [isOffline, viewerUserId])
const connect = useCallback(async () => {
+ if (credentialRetryRef.current.stopped || !isCurrentWsAccount(viewerUserId)) return
if (isPageHidden() || isOffline() || frozenRef.current) {
publishConnectionPhase(
isPageHidden() || frozenRef.current ? "suspended" : "reconnecting",
@@ -497,6 +550,7 @@ export function useUserWs(
|| isPageHidden()
|| isOffline()
|| frozenRef.current
+ || !isCurrentWsAccount(viewerUserId)
) return
const generation = previousGeneration + 1
connectionGenerationRef.current = generation
@@ -504,81 +558,105 @@ export function useUserWs(
clearTimeout(reconnectTimerRef.current)
reconnectTimerRef.current = null
}
- const tokenController = new AbortController()
- const tokenAttempt: PendingTokenAttempt = {
- controller: tokenController,
- generation,
- startedAt: Date.now(),
- reported: false,
- observationGeneration: telemetryGeneration(),
- }
- if (isTelemetryEligible()) emitTelemetry("ws.connect", { phase: "token", start_ms: performance.now(), outcome: "observed" })
- pendingTokenRef.current = tokenAttempt
- let tokenTimedOut = false
- tokenTimeoutRef.current = setTimeout(() => {
- if (pendingTokenRef.current !== tokenAttempt) return
- tokenTimedOut = true
- pendingTokenRef.current = null
- tokenTimeoutRef.current = null
- reportTokenAttempt(tokenAttempt, "timeout")
- trackCommunityWsAuthFailure({ failureClass: "timeout" })
- tokenController.abort()
- scheduleReconnect(generation)
- }, WS_TOKEN_TIMEOUT_MS)
+ const observationGeneration = telemetryGeneration()
+ const currentSession = currentSdkWsSession(viewerUserId)
+ const sdkSession = hasAuthenticatedBeforeRef.current
+ && currentSession?.session.id !== credentialRetryRef.current.rejectedSessionId
+ ? currentSession : undefined
let userId: string
let authToken: string
- let wsPort: number = WS_DO_PORT_DEFAULT
- let tokenResponseReceived = false
- try {
- const res = await fetch("/api/ws/token", { signal: tokenController.signal })
- tokenResponseReceived = true
- if (
- pendingTokenRef.current !== tokenAttempt
- || generation !== connectionGenerationRef.current
- || isOffline()
- ) return
- if (!res.ok) {
+ let wsPort = wsPortRef.current
+ if (sdkSession) {
+ userId = sdkSession.user.id
+ authToken = sdkSession.session.token
+ } else {
+ const tokenController = new AbortController()
+ const tokenAttempt: PendingTokenAttempt = {
+ controller: tokenController,
+ generation,
+ startedAt: Date.now(),
+ reported: false,
+ observationGeneration,
+ }
+ if (isTelemetryEligible()) emitTelemetry("ws.connect", { phase: "token", start_ms: performance.now(), outcome: "observed" })
+ pendingTokenRef.current = tokenAttempt
+ let tokenTimedOut = false
+ tokenTimeoutRef.current = setTimeout(() => {
+ if (pendingTokenRef.current !== tokenAttempt) return
+ tokenTimedOut = true
+ pendingTokenRef.current = null
+ tokenTimeoutRef.current = null
+ reportTokenAttempt(tokenAttempt, "timeout")
+ trackCommunityWsAuthFailure({ failureClass: "timeout" })
+ tokenController.abort()
+ scheduleReconnect(generation)
+ }, WS_TOKEN_TIMEOUT_MS)
+ const retry = credentialRetryRef.current
+ const refresh = Boolean(retry.rejectedSessionId) && !retry.refreshUsed
+ if (refresh) retry.refreshUsed = true
+ let tokenResponseReceived = false
+ try {
+ const res = await fetch(refresh ? "/api/ws/token?refresh=1" : "/api/ws/token", { signal: tokenController.signal })
+ tokenResponseReceived = true
+ if (
+ pendingTokenRef.current !== tokenAttempt
+ || generation !== connectionGenerationRef.current
+ || isOffline()
+ || !isCurrentWsAccount(viewerUserId)
+ ) return
+ if (!res.ok) {
+ reportTokenAttempt(tokenAttempt, "failure")
+ trackCommunityWsAuthFailure({ failureClass: tokenFailureClass(res.status) })
+ console.warn("[ws] token fetch failed:", res.status)
+ if (viewerUserId !== undefined && (res.status === 401 || res.status === 403)) stopCredentialRetry()
+ else scheduleReconnect(generation)
+ return
+ }
+ const body = await res.json() as { userId: string; token: string; wsPort?: number }
+ if (
+ pendingTokenRef.current !== tokenAttempt
+ || generation !== connectionGenerationRef.current
+ || isOffline()
+ || !isCurrentWsAccount(viewerUserId)
+ ) return
+ if (viewerUserId !== undefined && body.userId !== viewerUserId) {
+ reportTokenAttempt(tokenAttempt, "failure")
+ trackCommunityWsAuthFailure({ failureClass: "credentials" })
+ stopCredentialRetry()
+ return
+ }
+ reportTokenAttempt(tokenAttempt, "success")
+ userId = body.userId
+ authToken = body.token
+ if (body.wsPort) wsPort = body.wsPort
+ wsPortRef.current = wsPort
+ } catch (err) {
+ if (
+ pendingTokenRef.current !== tokenAttempt
+ || generation !== connectionGenerationRef.current
+ || isOffline()
+ || !isCurrentWsAccount(viewerUserId)
+ ) return
+ if (tokenController.signal.aborted || tokenTimedOut) return
reportTokenAttempt(tokenAttempt, "failure")
- trackCommunityWsAuthFailure({ failureClass: tokenFailureClass(res.status) })
- console.warn("[ws] token fetch failed:", res.status)
+ trackCommunityWsAuthFailure({
+ failureClass: tokenResponseReceived ? "unknown" : "network",
+ })
+ console.warn("[ws] token fetch error:", err)
scheduleReconnect(generation)
return
- }
- const body = await res.json() as { userId: string; token: string; wsPort?: number }
- if (
- pendingTokenRef.current !== tokenAttempt
- || generation !== connectionGenerationRef.current
- || isOffline()
- ) return
- reportTokenAttempt(tokenAttempt, "success")
- userId = body.userId
- authToken = body.token
- if (body.wsPort) wsPort = body.wsPort
- } catch (err) {
- if (
- pendingTokenRef.current !== tokenAttempt
- || generation !== connectionGenerationRef.current
- || isOffline()
- ) return
- if (tokenController.signal.aborted || tokenTimedOut) return
- reportTokenAttempt(tokenAttempt, "failure")
- trackCommunityWsAuthFailure({
- failureClass: tokenResponseReceived ? "unknown" : "network",
- })
- console.warn("[ws] token fetch error:", err)
- scheduleReconnect(generation)
- return
- } finally {
- if (pendingTokenRef.current === tokenAttempt) {
- if (tokenTimeoutRef.current !== null) {
- clearTimeout(tokenTimeoutRef.current)
- tokenTimeoutRef.current = null
+ } finally {
+ if (pendingTokenRef.current === tokenAttempt) {
+ if (tokenTimeoutRef.current !== null) {
+ clearTimeout(tokenTimeoutRef.current)
+ tokenTimeoutRef.current = null
+ }
+ pendingTokenRef.current = null
}
- pendingTokenRef.current = null
}
}
- if (generation !== connectionGenerationRef.current || isOffline()) return
+ if (generation !== connectionGenerationRef.current || isOffline() || !isCurrentWsAccount(viewerUserId)) return
const wsBaseUrl = useLocalServices
? websocketUrl("user", { local: true, port: wsPort })
@@ -590,6 +668,7 @@ export function useUserWs(
let openStageReported = false
let authStageReported = false
let authFailureReported = false
+ let protocolRejected = false
const reportOpenStage = (result: CommunityWsLifecycleStageResult) => {
if (openStageReported) return
openStageReported = true
@@ -620,9 +699,9 @@ export function useUserWs(
let pendingAdmissions = 0
let ws: WebSocket
try {
- if (generation !== connectionGenerationRef.current || isOffline()) return
+ if (generation !== connectionGenerationRef.current || isOffline() || !isCurrentWsAccount(viewerUserId)) return
retireSocket(true, "local-retire")
- if (generation !== connectionGenerationRef.current || isOffline()) return
+ if (generation !== connectionGenerationRef.current || isOffline() || !isCurrentWsAccount(viewerUserId)) return
ws = new WebSocket(url)
} catch (err) {
if (generation !== connectionGenerationRef.current) return
@@ -631,8 +710,8 @@ export function useUserWs(
scheduleReconnect(generation)
return
}
- observedSockets.current.set(ws, { generation: tokenAttempt.observationGeneration, start: performance.now() })
- if (tokenAttempt.observationGeneration === telemetryGeneration()) emitTelemetry("ws.connect", { phase: "transport", outcome: "observed" })
+ observedSockets.current.set(ws, { generation: observationGeneration, start: performance.now() })
+ if (observationGeneration === telemetryGeneration()) emitTelemetry("ws.connect", { phase: "transport", outcome: "observed" })
wsRef.current = ws
connectStartedAtRef.current = Date.now()
connectTimeoutRef.current = setTimeout(() => {
@@ -683,6 +762,7 @@ export function useUserWs(
return
}
const msg = parsed as Record<string, unknown>
+ if (msg.type === "auth.error") protocolRejected = true
if (typeof msg.type !== "string" || msg.type.length === 0) {
reportDroppedFrame("missing-type", msg)
return
@@ -723,6 +803,7 @@ export function useUserWs(
const confirmed = msg.communityContract ?? 1
if ((confirmed !== 1 && confirmed !== 2 && confirmed !== 3)
|| (confirmed !== requestedCommunityContract && !(confirmed === 1 && requestedCommunityContract === 2))) {
+ protocolRejected = true
reportDroppedFrame("invalid-payload", msg)
ws.close(1008, "Community contract confirmation mismatch")
return
@@ -827,10 +908,10 @@ export function useUserWs(
reportAuthStage(timeout ? "timeout" : aborted ? "aborted" : "failure")
if (initiator === "auth-failure") {
const code = normalizedCloseCode(event?.code)
- reportAuthFailure(code === 1008 ? "credentials" : "network")
+ reportAuthFailure(isWsCredentialRejection(event) && !protocolRejected ? "credentials" : code === 1008 ? "unknown" : "network")
} else if (initiator === "remote") {
const code = normalizedCloseCode(event?.code)
- reportAuthFailure(code === 1008 ? "credentials" : code === 1011 ? "server" : "network")
+ reportAuthFailure(isWsCredentialRejection(event) && !protocolRejected ? "credentials" : code === 1008 ? "unknown" : code === 1011 ? "server" : "network")
}
}
if (!ownsConnection(ws, generation)) return
@@ -852,6 +933,10 @@ export function useUserWs(
}
stopHeartbeat()
if (connectTimeoutRef.current !== null) { clearTimeout(connectTimeoutRef.current); connectTimeoutRef.current = null }
+ if (!wasAuthenticated && viewerUserId !== undefined && !protocolRejected && isWsCredentialRejection(event)) {
+ if (sdkSession) credentialRetryRef.current.rejectedSessionId = sdkSession.session.id
+ else stopCredentialRetry()
+ }
publishConnectionPhase(
isPageHidden() || frozenRef.current ? "suspended" : "reconnecting",
)
@@ -874,7 +959,9 @@ export function useUserWs(
retireSocket,
scheduleReconnect,
startHeartbeat,
+ stopCredentialRetry,
stopHeartbeat,
+ viewerUserId,
])
useEffect(() => {
@@ -1021,6 +1108,40 @@ export function useUserWs(
validateCurrentConnection,
])
+ useEffect(() => {
+ if (previousViewerRef.current !== viewerUserId) {
+ previousViewerRef.current = viewerUserId
+ credentialRetryRef.current = { rejectedSessionId: null, refreshUsed: false, stopped: false, refetchUsed: false }
+ wsPortRef.current = WS_DO_PORT_DEFAULT
+ hasAuthenticatedBeforeRef.current = false
+ authenticatedGenerationRef.current = null
+ disconnectedAtRef.current = null
+ reconnectDelay.current = WS_RECONNECT_INIT
+ reconnectAttemptRef.current = 0
+ }
+ if (!viewerUserId) return
+ return authClient.$store.atoms.session.listen((current, previous) => {
+ if (current.isPending || current.error) return
+ const sameOwner = current.data?.user?.id === viewerUserId
+ const previousSession = previous?.data?.session
+ const session = current.data?.session
+ const changed = previousSession?.id !== session?.id || previousSession?.token !== session?.token
+ if (sameOwner && !changed) return
+ if (sameOwner) {
+ credentialRetryRef.current = { rejectedSessionId: null, refreshUsed: false, stopped: false, refetchUsed: false }
+ if (!previousSession && (wsRef.current || pendingTokenRef.current)) return
+ } else credentialRetryRef.current.stopped = true
+ connectionGenerationRef.current += 1
+ abortPendingToken()
+ if (reconnectTimerRef.current !== null) {
+ clearTimeout(reconnectTimerRef.current)
+ reconnectTimerRef.current = null
+ }
+ retireSocket(true, "local-retire")
+ if (sameOwner) void connectRef.current?.()
+ })
+ }, [abortPendingToken, retireSocket, viewerUserId])
+
useEffect(() => {
const mountedAt = Date.now()
if (isPageHidden() || isOffline()) suspendedAtRef.current = mountedAt
@@ -1116,12 +1237,16 @@ export function useUserWs(
const send = useCallback((msg: object) => {
const ws = wsRef.current
- if (!isOffline() && ws?.readyState === WebSocket.OPEN) {
+ if (!isOffline() && isCurrentWsAccount(viewerUserId) && ws?.readyState === WebSocket.OPEN) {
ws.send(JSON.stringify(msg))
}
- }, [isOffline])
+ }, [isOffline, viewerUserId])
const reconnectNow = useCallback(() => {
+ credentialRetryRef.current = {
+ rejectedSessionId: credentialRetryRef.current.rejectedSessionId,
+ refreshUsed: false, stopped: false, refetchUsed: false,
+ }
clearConnectionValidation("aborted")
if (reconnectTimerRef.current !== null) {
clearTimeout(reconnectTimerRef.current)
diff --git a/src/web/src/test/e2e-ui/25-community-ws-reconnect-overlay.spec.ts b/src/web/src/test/e2e-ui/25-community-ws-reconnect-overlay.spec.ts
index a768729f6..e11d53dec 100644
--- a/src/web/src/test/e2e-ui/25-community-ws-reconnect-overlay.spec.ts
+++ b/src/web/src/test/e2e-ui/25-community-ws-reconnect-overlay.spec.ts
@@ -78,28 +78,94 @@ test("slow auth and an initial retry never block a cold Community page", async (
}
})
-test("a real WebSocket outage keeps cached content interactive and Retry reconnects", async ({ asUser }) => {
+test("a real WebSocket outage keeps cached content interactive and Retry reconnects", async ({ asUser }, testInfo) => {
test.setTimeout(120_000)
const serverId = await seedServer("alice", `Reconnect status ${Date.now()}`)
const channelId = await seedChannel("alice", serverId, "reconnect-status")
const alice = await asUser("alice")
let authenticatedConnections = 0
+ let firstTarget: string | null = null
+ let bootstrapStartedAt = 0
+ let bootstrapAuthenticatedAt: number | null = null
+ let recoveryStartedAt: number | null = null
+ let retryStartedAt: number | null = null
+ let recoveryAuthenticatedAt: number | null = null
+ let holdReconnectAuth = false
+ let heldAuthOkCount = 0
+ const heldAuthOk = new Map<WebSocketRoute, string | Buffer>()
+ const tokenTimings: Array<{ startMs: number; endMs: number | null; status: number | null }> = []
+ const socketTimings: Array<{ connection: number; observedMs: number; authSentMs: number | null; authOkMs: number | null }> = []
+ const tokenRequests = new WeakMap<object, typeof tokenTimings[number]>()
+ alice.page.on("request", (request) => {
+ if (new URL(request.url()).pathname !== "/api/ws/token") return
+ const stage = { startMs: performance.now(), endMs: null, status: null }
+ tokenTimings.push(stage)
+ tokenRequests.set(request, stage)
+ })
+ alice.page.on("response", (response) => {
+ const stage = tokenRequests.get(response.request())
+ if (stage) { stage.endMs = performance.now(); stage.status = response.status() }
+ })
alice.page.on("websocket", (socket) => {
+ const url = new URL(socket.url())
+ if (!url.pathname.endsWith("/user")) return
+ firstTarget ??= url.searchParams.get("userId")
+ const stage: typeof socketTimings[number] = { connection: socketTimings.length + 1, observedMs: performance.now(), authSentMs: null, authOkMs: null }
+ socketTimings.push(stage)
+ socket.on("framesent", ({ payload }) => {
+ try {
+ if (JSON.parse(payload.toString()).type === "auth") stage.authSentMs ??= performance.now()
+ } catch {}
+ })
socket.on("framereceived", ({ payload }) => {
try {
- if (JSON.parse(payload.toString()).type === "auth.ok") authenticatedConnections += 1
+ if (JSON.parse(payload.toString()).type === "auth.ok") {
+ stage.authOkMs ??= performance.now()
+ authenticatedConnections += 1
+ if (bootstrapAuthenticatedAt === null) bootstrapAuthenticatedAt = performance.now()
+ else recoveryAuthenticatedAt ??= performance.now()
+ }
} catch {}
})
})
let aliceWs: WebSocketRoute | null = null
await alice.page.routeWebSocket((url) => url.pathname.endsWith("/user"), (ws) => {
aliceWs = ws
- ws.connectToServer()
+ const server = ws.connectToServer()
+ server.onMessage((message) => {
+ let authenticated = false
+ try { authenticated = JSON.parse(message.toString()).type === "auth.ok" } catch {}
+ if (holdReconnectAuth && authenticated) { heldAuthOkCount++; heldAuthOk.set(ws, message); return }
+ ws.send(message)
+ })
})
+ const releaseReconnectAuth = (retiredForRetry: WebSocketRoute | null = null) => {
+ holdReconnectAuth = false
+ for (const [ws, message] of heldAuthOk) {
+ if (ws === aliceWs && ws !== retiredForRetry) ws.send(message)
+ }
+ heldAuthOk.clear()
+ }
await alice.page.setViewportSize({ width: 390, height: 844 })
+ const sdkReady = alice.page.waitForResponse((response) => new URL(response.url()).pathname.endsWith("/get-session") && response.ok())
+ bootstrapStartedAt = performance.now()
await gotoAfterUserWsAuth(alice.page, `/c/channels/${serverId}/${channelId}`)
+ const sdk = await (await sdkReady).json() as { user: { id: string }; session: { token: string; expiresAt: string } }
+ expect(sdk.user.id).toBe(firstTarget)
+ expect(sdk.session.token.length).toBeGreaterThan(0)
+ expect(Date.parse(sdk.session.expiresAt)).toBeGreaterThan(Date.now())
const composer = composerEditable(alice.page)
await expect(composer).toBeVisible()
+ const bootstrapTokenCount = tokenTimings.length
+ expect(bootstrapTokenCount).toBeGreaterThan(0)
+ let holdReconnectTokens = true
+ let releaseReconnectTokens!: () => void
+ const reconnectTokenGate = new Promise<void>(resolve => { releaseReconnectTokens = resolve })
+ const gateReconnectToken: Parameters<Page["route"]>[1] = async (route) => {
+ if (holdReconnectTokens) await reconnectTokenGate
+ await route.continue()
+ }
+ await alice.page.route("**/api/ws/token**", gateReconnectToken)
try {
await alice.context.setOffline(true)
@@ -126,18 +192,48 @@ test("a real WebSocket outage keeps cached content interactive and Retry reconne
expect(rect!.height).toBeLessThan(844)
expect((await retry.boundingBox())!.height).toBeGreaterThanOrEqual(44)
+ holdReconnectAuth = true
+ recoveryStartedAt = performance.now()
await alice.context.setOffline(false)
await retry.focus()
await expect(retry).toBeFocused()
+ retryStartedAt = performance.now()
+ const retiredForRetry = aliceWs
await alice.page.keyboard.press("Enter")
+ releaseReconnectAuth(retiredForRetry)
await expect(status).toHaveCount(0, { timeout: 20_000 })
await expect(composer).toBeVisible()
await expect.poll(() => composer.evaluate((element) => element.closest("[inert]") !== null))
.toBe(false)
await expect.poll(() => authenticatedConnections, { timeout: 20_000 })
.toBeGreaterThanOrEqual(2)
+ expect(tokenTimings).toHaveLength(bootstrapTokenCount)
+ expect(recoveryAuthenticatedAt).not.toBeNull()
} finally {
+ releaseReconnectAuth()
+ holdReconnectTokens = false
+ releaseReconnectTokens()
+ await alice.page.unroute("**/api/ws/token**", gateReconnectToken)
await alice.context.setOffline(false).catch(() => {})
+ await testInfo.attach("ws-sdk-reconnect-stages.json", {
+ body: Buffer.from(JSON.stringify({
+ clock: "test-runner performance.now(); browser event delivery timestamps",
+ bootstrapStartedAt, bootstrapAuthenticatedAt,
+ recoveryStartedAt, retryStartedAt, recoveryAuthenticatedAt,
+ bootstrapActionToAuthMs: bootstrapAuthenticatedAt === null ? null : bootstrapAuthenticatedAt - bootstrapStartedAt,
+ recoveryActionToAuthMs: recoveryAuthenticatedAt === null || recoveryStartedAt === null ? null : recoveryAuthenticatedAt - recoveryStartedAt,
+ retryActionToAuthMs: recoveryAuthenticatedAt === null || retryStartedAt === null ? null : recoveryAuthenticatedAt - retryStartedAt,
+ tokenTimings, bootstrapTokenCount, reconnectTokenCount: tokenTimings.length - bootstrapTokenCount,
+ socketTimings: socketTimings.map(stage => ({
+ ...stage,
+ observedToAuthFrameMs: stage.authSentMs === null ? null : stage.authSentMs - stage.observedMs,
+ authFrameToAckMs: stage.authOkMs === null || stage.authSentMs === null ? null : stage.authOkMs - stage.authSentMs,
+ })),
+ heldAuthOkCount,
+ boundary: "Times are browser-event delivery observations, not exact network/open times. Recovery includes manual Retry and a test auth.ok gate; the current replacement's held server frame is released after Enter. No same-load latency comparison or fixed production saving.",
+ })),
+ contentType: "application/json",
+ })
}
})
diff --git a/src/web/src/test/e2e-ui/32-mobile-ws-foreground-validation.spec.ts b/src/web/src/test/e2e-ui/32-mobile-ws-foreground-validation.spec.ts
index b74acdf0f..84dfd3604 100644
--- a/src/web/src/test/e2e-ui/32-mobile-ws-foreground-validation.spec.ts
+++ b/src/web/src/test/e2e-ui/32-mobile-ws-foreground-validation.spec.ts
@@ -204,7 +204,7 @@ test("mobile foreground proof is exact, bounded, and recovers through one curren
await setVisibility("visible", false)
await dispatchDuplicateResumeSignals()
await expect.poll(() => proxy.connectionCount()).toBe(freezeConnectionBaseline + 1)
- await expect.poll(() => tokenRequests).toBe(freezeTokenBaseline + 1)
+ await expect.poll(() => tokenRequests).toBe(freezeTokenBaseline)
await expect.poll(() => proxy.connectionFrames.filter((frame) =>
frame.direction === "server-to-client"
&& frame.type === "auth.ok"
@@ -232,12 +232,12 @@ test("mobile foreground proof is exact, bounded, and recovers through one curren
await expect.poll(() => proxy.connectionCount()).toBe(failedConnectionBaseline + 1)
await expect(wsOverlay).toHaveCount(0)
- await expect.poll(() => tokenRequests).toBe(failedTokenBaseline + 1)
+ await expect.poll(() => tokenRequests).toBe(failedTokenBaseline)
await expect.poll(() => proxy.heldConnectionCount()).toBe(1)
await dispatchDuplicateResumeSignals()
await alice.page.waitForTimeout(250)
expect(proxy.connectionCount()).toBe(failedConnectionBaseline + 1)
- expect(tokenRequests).toBe(failedTokenBaseline + 1)
+ expect(tokenRequests).toBe(failedTokenBaseline)
expect(proxy.heldConnectionCount()).toBe(1)
expect(proxy.connectionFrames.filter((frame) =>
frame.direction === "client-to-server"
@@ -284,7 +284,7 @@ test("mobile foreground proof is exact, bounded, and recovers through one curren
{ timeout: WS_CONNECTION_VALIDATION_TIMEOUT_MS + 5_000 },
).toBe(sentinelConnectionBaseline + 1)
await expect(wsOverlay).toHaveCount(0)
- await expect.poll(() => tokenRequests).toBe(sentinelTokenBaseline + 1)
+ await expect.poll(() => tokenRequests).toBe(sentinelTokenBaseline)
await expect.poll(() => proxy.heldConnectionCount()).toBe(1)
expect(proxy.connectionFrames.slice(sentinelRecoveryStart).filter((frame) =>
frame.direction === "client-to-server" && frame.type === "connection.ping",
@@ -337,7 +337,7 @@ test("mobile foreground proof is exact, bounded, and recovers through one curren
{ timeout: 20_000 },
)
await expect.poll(() => proxy.connectionCount()).toBe(onlineRecoveryConnectionBaseline + 1)
- await expect.poll(() => successfulTokenResponses).toBe(onlineRecoverySuccessfulTokenBaseline + 1)
+ await expect.poll(() => successfulTokenResponses).toBe(onlineRecoverySuccessfulTokenBaseline)
expect(proxy.connectionFrames.slice(onlineRecoveryFrameStart).filter((frame) =>
frame.direction === "server-to-client"
&& frame.connectionId === onlineRecoveryConnectionBaseline + 1