Multi-Agent Collaboration for Team and Friends
TypeScript agent-automationagent-orchestrationagent-workflowai-agentsai-collaborationai-memoryai-workforceautonomous-agentsclaude-codeclaude-code-skillscodexcoding-agentmulti-agentmultiple-agentone-person-businessone-person-companyone-person-teamopencodesolopreneur
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.tsnew file mode 100644index 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.tsindex 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.tsindex 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 | undefinedlet 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.tsindex 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.tsxnew file mode 100644index 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.tsindex 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 = nullrefs = 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.tsindex 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 | nullcommunityContract?: CommunityContractonReconnect?: (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)) returnif (isPageHidden() || isOffline() || frozenRef.current) returnif (reconnectTimerRef.current !== null) {clearTimeout(reconnectTimerRef.current)@@ -479,9 +531,10 @@ export function useUserWs() returnvoid connectRef.current?.()}, delayMs)- }, [isOffline])+ }, [isOffline, viewerUserId])const connect = useCallback(async () => {+ if (credentialRetryRef.current.stopped || !isCurrentWsAccount(viewerUserId)) returnif (isPageHidden() || isOffline() || frozenRef.current) {publishConnectionPhase(isPageHidden() || frozenRef.current ? "suspended" : "reconnecting",@@ -497,6 +550,7 @@ export function useUserWs(|| isPageHidden()|| isOffline()|| frozenRef.current+ || !isCurrentWsAccount(viewerUserId)) returnconst generation = previousGeneration + 1connectionGenerationRef.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 : undefinedlet userId: stringlet 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) returnreportTokenAttempt(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)) returnconst wsBaseUrl = useLocalServices? websocketUrl("user", { local: true, port: wsPort })@@ -590,6 +668,7 @@ export function useUserWs(let openStageReported = falselet authStageReported = falselet authFailureReported = false+ let protocolRejected = falseconst reportOpenStage = (result: CommunityWsLifecycleStageResult) => {if (openStageReported) returnopenStageReported = true@@ -620,9 +699,9 @@ export function useUserWs(let pendingAdmissions = 0let ws: WebSockettry {- if (generation !== connectionGenerationRef.current || isOffline()) return+ if (generation !== connectionGenerationRef.current || isOffline() || !isCurrentWsAccount(viewerUserId)) returnretireSocket(true, "local-retire")- if (generation !== connectionGenerationRef.current || isOffline()) return+ if (generation !== connectionGenerationRef.current || isOffline() || !isCurrentWsAccount(viewerUserId)) returnws = 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 = wsconnectStartedAtRef.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 = trueif (typeof msg.type !== "string" || msg.type.length === 0) {reportDroppedFrame("missing-type", msg)return@@ -723,6 +803,7 @@ export function useUserWs(const confirmed = msg.communityContract ?? 1if ((confirmed !== 1 && confirmed !== 2 && confirmed !== 3)|| (confirmed !== requestedCommunityContract && !(confirmed === 1 && requestedCommunityContract === 2))) {+ protocolRejected = truereportDroppedFrame("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.tsindex 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 = nullawait 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 reconneexpect(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 = aliceWsawait 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.tsindex 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 currenawait 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 currenawait 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