Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

fix(frontend): coordinate HTTP token refresh with a shared worker (#21622)

p0ny844a319bf090
diff --git a/frontend/src/api/middlewares/authInterceptorMiddleware.test.ts b/frontend/src/api/middlewares/authInterceptorMiddleware.test.ts
index 9d8e5769de..01591801dc 100644
--- a/frontend/src/api/middlewares/authInterceptorMiddleware.test.ts
+++ b/frontend/src/api/middlewares/authInterceptorMiddleware.test.ts
@@ -109,6 +109,129 @@ describe("authInterceptor", () => {
expect(mocks.authStore.unauthenticatedOccurred).toBe(false);
});
+ test("recovers worker startup before marking the session expired", async () => {
+ const { refreshTokensInWorker } = await import(
+ "../refreshTokenSharedWorker"
+ );
+ const refreshRequests = vi.fn();
+ let attempts = 0;
+ class StartupWorker extends EventTarget {
+ port = Object.assign(new EventTarget(), {
+ start: vi.fn(),
+ close: vi.fn(),
+ postMessage: () => {
+ refreshRequests();
+ queueMicrotask(() =>
+ this.port.dispatchEvent(new MessageEvent("message", { data: {} }))
+ );
+ },
+ });
+ constructor() {
+ super();
+ const fail = ++attempts === 1;
+ queueMicrotask(() => {
+ if (fail) this.dispatchEvent(new Event("error"));
+ else {
+ this.port.dispatchEvent(
+ new MessageEvent("message", { data: { ready: true } })
+ );
+ }
+ });
+ }
+ }
+ vi.stubGlobal("SharedWorker", StartupWorker);
+ mocks.refreshTokens.mockImplementation(refreshTokensInWorker);
+ const next = vi
+ .fn()
+ .mockRejectedValueOnce(
+ new ConnectError("access token not found", Code.Unauthenticated)
+ )
+ .mockResolvedValueOnce({ ok: true });
+ try {
+ await expect(authInterceptor(next)(createRequest())).resolves.toEqual({
+ ok: true,
+ });
+ expect(attempts).toBe(2);
+ expect(refreshRequests).toHaveBeenCalledTimes(1);
+ expect(next).toHaveBeenCalledTimes(2);
+ expect(mocks.authStore.unauthenticatedOccurred).toBe(false);
+ expect(mocks.pushNotification).not.toHaveBeenCalled();
+ } finally {
+ vi.unstubAllGlobals();
+ }
+ });
+
+ test.each([false, true])(
+ "startup exhaustion preserves the session and later recovers (silent=%s)",
+ async (silent) => {
+ vi.resetModules();
+ const { refreshTokensInWorker } = await import(
+ "../refreshTokenSharedWorker"
+ );
+ const { authInterceptor: interceptor } = await import(
+ "./authInterceptorMiddleware"
+ );
+ let attempts = 0;
+ let available = false;
+ const refreshRequests = vi.fn();
+ class StartupWorker extends EventTarget {
+ port = Object.assign(new EventTarget(), {
+ start: vi.fn(),
+ close: vi.fn(),
+ postMessage: () => {
+ refreshRequests();
+ queueMicrotask(() =>
+ this.port.dispatchEvent(new MessageEvent("message", { data: {} }))
+ );
+ },
+ });
+ constructor() {
+ super();
+ attempts++;
+ queueMicrotask(() => {
+ if (!available) this.dispatchEvent(new Event("error"));
+ else
+ this.port.dispatchEvent(
+ new MessageEvent("message", { data: { ready: true } })
+ );
+ });
+ }
+ }
+ vi.stubGlobal("SharedWorker", StartupWorker);
+ mocks.refreshTokens.mockImplementation(refreshTokensInWorker);
+ const next = vi
+ .fn()
+ .mockRejectedValue(
+ new ConnectError("access token expired", Code.Unauthenticated)
+ );
+ try {
+ for (let outage = 0; outage < 2; outage++) {
+ await expect(
+ interceptor(next)(createRequest({ silent }))
+ ).rejects.toMatchObject({ code: Code.Unavailable });
+ expect(mocks.authStore.unauthenticatedOccurred).toBe(false);
+ expect(mocks.pushNotification).not.toHaveBeenCalled();
+ expect(refreshRequests).not.toHaveBeenCalled();
+ }
+ expect(attempts).toBe(6);
+ available = true;
+ next
+ .mockRejectedValueOnce(
+ new ConnectError("access token expired", Code.Unauthenticated)
+ )
+ .mockResolvedValueOnce({ ok: true });
+ await expect(
+ interceptor(next)(createRequest({ silent }))
+ ).resolves.toEqual({ ok: true });
+ expect(refreshRequests).toHaveBeenCalledTimes(1);
+ expect(mocks.authStore.unauthenticatedOccurred).toBe(false);
+ expect(mocks.pushNotification).not.toHaveBeenCalled();
+ } finally {
+ vi.unstubAllGlobals();
+ }
+ }
+ );
+
test("keeps silent unauthenticated refresh failures notification-free", async () => {
const next = vi
.fn()
diff --git a/frontend/src/api/middlewares/authInterceptorMiddleware.ts b/frontend/src/api/middlewares/authInterceptorMiddleware.ts
index c31c35b7b7..49ead9934d 100644
--- a/frontend/src/api/middlewares/authInterceptorMiddleware.ts
+++ b/frontend/src/api/middlewares/authInterceptorMiddleware.ts
@@ -14,6 +14,7 @@ import { PermissionDeniedDetailSchema } from "@/types/proto-es/v1/common_pb";
import { appStoreUtilBridge } from "@/utils/app-store-bridge";
import { ignoredCodesContextKey, silentContextKey } from "../context-key";
import { refreshTokens } from "../refreshToken";
+import { WorkerStartupError } from "../refreshTokenSharedWorker";
const extractPermissionDeniedDetail = (error: unknown) => {
if (error instanceof ConnectError) {
@@ -92,6 +93,12 @@ export const authInterceptor: Interceptor = (next) => async (req) => {
try {
await refreshTokens();
} catch (e) {
+ if (e instanceof WorkerStartupError) {
+ throw new ConnectError(
+ "Session refresh temporarily unavailable",
+ Code.Unavailable
+ );
+ }
console.error(e);
handleUnauthenticatedFailure({
silent,
diff --git a/frontend/src/api/refreshToken.test.ts b/frontend/src/api/refreshToken.test.ts
new file mode 100644
index 0000000000..b7bed5bb06
--- /dev/null
+++ b/frontend/src/api/refreshToken.test.ts
@@ -0,0 +1,46 @@
+import { afterEach, beforeEach, expect, test, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({ refresh: vi.fn(), workerRefresh: vi.fn() }));
+vi.mock("@/api", () => ({
+ authServiceClientConnect: { refresh: mocks.refresh },
+}));
+vi.mock("./refreshTokenSharedWorker", () => ({
+ refreshTokensInWorker: mocks.workerRefresh,
+}));
+
+import { refreshTokens } from "./refreshToken";
+
+beforeEach(() => {
+ mocks.refresh.mockReset().mockResolvedValue({});
+ mocks.workerRefresh.mockReset().mockResolvedValue(undefined);
+});
+afterEach(() => vi.unstubAllGlobals());
+
+test("uses Web Locks when available without starting a SharedWorker", async () => {
+ const request = vi.fn(
+ (
+ _name: string,
+ _options: LockOptions,
+ callback: (lock: Lock) => Promise<boolean>
+ ) => callback({ name: "bb_token_refresh", mode: "exclusive" })
+ );
+ vi.stubGlobal("navigator", { locks: { request } });
+ await refreshTokens();
+ expect(request).toHaveBeenCalledTimes(1);
+ expect(mocks.refresh).toHaveBeenCalledTimes(1);
+ expect(mocks.workerRefresh).not.toHaveBeenCalled();
+});
+
+test("shares the SharedWorker fallback between callers without Web Locks", async () => {
+ vi.stubGlobal("navigator", {});
+ await Promise.all([refreshTokens(), refreshTokens()]);
+ expect(mocks.workerRefresh).toHaveBeenCalledTimes(1);
+ expect(mocks.refresh).not.toHaveBeenCalled();
+});
+
+test("propagates fallback errors without an uncoordinated retry", async () => {
+ vi.stubGlobal("navigator", {});
+ mocks.workerRefresh.mockRejectedValue(new Error("worker failed"));
+ await expect(refreshTokens()).rejects.toThrow("worker failed");
+ expect(mocks.refresh).not.toHaveBeenCalled();
+});
diff --git a/frontend/src/api/refreshToken.ts b/frontend/src/api/refreshToken.ts
index e15131dca5..33b6818d07 100644
--- a/frontend/src/api/refreshToken.ts
+++ b/frontend/src/api/refreshToken.ts
@@ -1,4 +1,5 @@
import { authServiceClientConnect } from "@/api";
+import { refreshTokensInWorker } from "./refreshTokenSharedWorker";
const LOCK_NAME = "bb_token_refresh";
const CHANNEL_NAME = "bb_token_refresh";
@@ -8,7 +9,7 @@ let localPromise: Promise<void> | null = null;
/**
* Refresh the access token using the refresh token cookie.
- * Uses Web Lock API for cross-tab coordination.
+ * Uses Web Locks for cross-tab coordination, or a SharedWorker on HTTP.
* Only one tab performs the refresh; others wait for completion.
*/
export async function refreshTokens(): Promise<void> {
@@ -39,6 +40,10 @@ async function doRefresh(): Promise<void> {
}
async function tryAcquireAndRefresh(): Promise<boolean> {
+ if (!navigator.locks) {
+ await refreshTokensInWorker();
+ return true;
+ }
return navigator.locks.request(
LOCK_NAME,
{ ifAvailable: true },
diff --git a/frontend/src/api/refreshToken.worker.test.ts b/frontend/src/api/refreshToken.worker.test.ts
new file mode 100644
index 0000000000..13ae2474a0
--- /dev/null
+++ b/frontend/src/api/refreshToken.worker.test.ts
@@ -0,0 +1,87 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({ refresh: vi.fn() }));
+vi.mock("@connectrpc/connect", () => ({ createClient: () => mocks }));
+vi.mock("@connectrpc/connect-web", () => ({ createConnectTransport: vi.fn() }));
+
+function connect() {
+ const port = {
+ onmessage: undefined as undefined | (() => Promise<void>),
+ postMessage: vi.fn(),
+ };
+ (globalThis as unknown as { onconnect: (event: unknown) => void }).onconnect({
+ ports: [port],
+ });
+ return port;
+}
+
+beforeEach(async () => {
+ vi.resetModules();
+ mocks.refresh.mockReset();
+ await import("./refreshToken.worker");
+});
+
+afterEach(() => vi.useRealTimers());
+
+describe("shared refresh worker", () => {
+ test("lets a slow rotation finish without a client deadline", async () => {
+ vi.useFakeTimers();
+ const response = Promise.withResolvers<void>();
+ mocks.refresh.mockReturnValue(response.promise);
+ const a = connect();
+ const first = a.onmessage!();
+ expect(mocks.refresh).toHaveBeenCalledExactlyOnceWith({});
+ await vi.advanceTimersByTimeAsync(40000);
+ const b = connect();
+ const second = b.onmessage!();
+ expect(mocks.refresh).toHaveBeenCalledTimes(1);
+ expect(a.postMessage).toHaveBeenCalledExactlyOnceWith({ ready: true });
+ expect(b.postMessage).toHaveBeenCalledExactlyOnceWith({ ready: true });
+ response.resolve();
+ await Promise.all([first, second]);
+ expect(a.postMessage).toHaveBeenLastCalledWith({});
+ expect(b.postMessage).toHaveBeenLastCalledWith({});
+ });
+
+ test("two tabs share one request and a later refresh can rotate again", async () => {
+ const response = Promise.withResolvers<void>();
+ mocks.refresh
+ .mockReturnValueOnce(response.promise)
+ .mockResolvedValue(undefined);
+ const a = connect();
+ const b = connect();
+ const first = a.onmessage!();
+ const second = b.onmessage!();
+ expect(mocks.refresh).toHaveBeenCalledTimes(1);
+ expect(a.postMessage).toHaveBeenCalledExactlyOnceWith({ ready: true });
+ expect(b.postMessage).toHaveBeenCalledExactlyOnceWith({ ready: true });
+ response.resolve();
+ await Promise.all([first, second]);
+ expect(a.postMessage).toHaveBeenCalledWith({});
+ expect(b.postMessage).toHaveBeenCalledWith({});
+ await b.onmessage!();
+ expect(mocks.refresh).toHaveBeenCalledTimes(2);
+ });
+
+ test("all waiting tabs receive a failed refresh and later calls can recover", async () => {
+ const response = Promise.withResolvers<void>();
+ mocks.refresh
+ .mockReturnValueOnce(response.promise)
+ .mockResolvedValue(undefined);
+ const a = connect();
+ const b = connect();
+ const first = a.onmessage!();
+ const second = b.onmessage!();
+ response.reject(new Error("invalid refresh token"));
+ await Promise.all([first, second]);
+ expect(mocks.refresh).toHaveBeenCalledTimes(1);
+ expect(a.postMessage).toHaveBeenCalledWith({
+ error: "invalid refresh token",
+ });
+ expect(b.postMessage).toHaveBeenCalledWith({
+ error: "invalid refresh token",
+ });
+ await a.onmessage!();
+ expect(a.postMessage).toHaveBeenLastCalledWith({});
+ });
+});
diff --git a/frontend/src/api/refreshToken.worker.ts b/frontend/src/api/refreshToken.worker.ts
new file mode 100644
index 0000000000..052caab80b
--- /dev/null
+++ b/frontend/src/api/refreshToken.worker.ts
@@ -0,0 +1,42 @@
+import { createClient } from "@connectrpc/connect";
+import { createConnectTransport } from "@connectrpc/connect-web";
+import { AuthService } from "@/types/proto-es/v1/auth_service_pb";
+
+const client = createClient(
+ AuthService,
+ createConnectTransport({
+ baseUrl: import.meta.env.BB_GRPC_LOCAL || globalThis.location.origin,
+ fetch: (input, init) => fetch(input, { ...init, credentials: "include" }),
+ })
+);
+
+let pending: Promise<void> | undefined;
+
+const scope = globalThis as unknown as {
+ onconnect: (event: MessageEvent) => void;
+};
+
+scope.onconnect = (event) => {
+ const port = event.ports[0];
+ port.onmessage = async () => {
+ // The worker owns the network request, so closing the initiating tab
+ // does not hand an in-flight refresh to another tab.
+ pending ??= client
+ .refresh({})
+ .then(() => {})
+ .finally(() => {
+ pending = undefined;
+ });
+ let result: { error?: string } = {};
+ try {
+ await pending;
+ } catch (error) {
+ result = {
+ error:
+ error instanceof Error ? error.message : "Session refresh failed",
+ };
+ }
+ port.postMessage(result);
+ };
+ port.postMessage({ ready: true });
+};
diff --git a/frontend/src/api/refreshTokenSharedWorker.test.ts b/frontend/src/api/refreshTokenSharedWorker.test.ts
new file mode 100644
index 0000000000..73763808d0
--- /dev/null
+++ b/frontend/src/api/refreshTokenSharedWorker.test.ts
@@ -0,0 +1,162 @@
+import { afterEach, beforeEach, expect, test, vi } from "vitest";
+
+class TestWorker extends EventTarget {
+ port = Object.assign(new EventTarget(), {
+ start: vi.fn(),
+ close: vi.fn(),
+ postMessage: vi.fn(),
+ });
+}
+let worker: TestWorker;
+let construct: ReturnType<typeof vi.fn>;
+let refreshTokensInWorker: typeof import("./refreshTokenSharedWorker").refreshTokensInWorker;
+
+beforeEach(async () => {
+ vi.resetModules();
+ worker = new TestWorker();
+ construct = vi.fn(function () {
+ return worker;
+ });
+ vi.stubGlobal("SharedWorker", construct);
+ ({ refreshTokensInWorker } = await import("./refreshTokenSharedWorker"));
+});
+afterEach(() => {
+ vi.unstubAllGlobals();
+ vi.useRealTimers();
+});
+
+function respond(data: { ready?: boolean; error?: string } = {}) {
+ worker.port.dispatchEvent(new MessageEvent("message", { data }));
+}
+
+test("shares one request within a tab without Web Locks and reuses the worker", async () => {
+ vi.stubGlobal("navigator", {});
+ const a = refreshTokensInWorker();
+ const b = refreshTokensInWorker();
+ expect(a).toBe(b);
+ expect(worker.port.postMessage).not.toHaveBeenCalled();
+ respond({ ready: true });
+ expect(worker.port.postMessage).toHaveBeenCalledTimes(1);
+ respond();
+ await Promise.all([a, b]);
+ const c = refreshTokensInWorker();
+ respond();
+ await c;
+ expect(construct).toHaveBeenCalledTimes(1);
+ expect(worker.port.postMessage).toHaveBeenCalledTimes(2);
+});
+
+test("propagates authentication errors and can refresh after signing in again", async () => {
+ const first = expect(refreshTokensInWorker()).rejects.toThrow(
+ "invalid refresh token"
+ );
+ respond({ ready: true });
+ respond({ error: "invalid refresh token" });
+ await first;
+ const next = refreshTokensInWorker();
+ respond();
+ await next;
+});
+
+test("worker failure after readiness prevents independent retries", async () => {
+ const first = expect(refreshTokensInWorker()).rejects.toThrow(
+ "worker failed"
+ );
+ respond({ ready: true });
+ worker.dispatchEvent(new Event("error"));
+ await first;
+ await expect(refreshTokensInWorker()).rejects.toThrow("worker failed");
+ expect(construct).toHaveBeenCalledTimes(1);
+ expect(worker.port.postMessage).toHaveBeenCalledTimes(1);
+});
+
+test("slow startup leaves a full watchdog interval for refresh", async () => {
+ vi.useFakeTimers();
+ const first = refreshTokensInWorker();
+ const rejected = vi.fn();
+ void first.catch(rejected);
+ await vi.advanceTimersByTimeAsync(34000);
+ expect(worker.port.postMessage).not.toHaveBeenCalled();
+ respond({ ready: true });
+ await vi.advanceTimersByTimeAsync(34000);
+ expect(rejected).not.toHaveBeenCalled();
+ expect(worker.port.postMessage).toHaveBeenCalledExactlyOnceWith("refresh");
+ respond();
+ await first;
+ const later = refreshTokensInWorker();
+ respond();
+ await later;
+ expect(construct).toHaveBeenCalledTimes(1);
+});
+
+test("a silent worker times out without starting another refresh", async () => {
+ vi.useFakeTimers();
+ const first = expect(refreshTokensInWorker()).rejects.toThrow(
+ "worker failed"
+ );
+ respond({ ready: true });
+ await vi.advanceTimersByTimeAsync(35000);
+ await first;
+ respond();
+ await expect(refreshTokensInWorker()).rejects.toThrow("worker failed");
+ expect(worker.port.postMessage).toHaveBeenCalledTimes(1);
+});
+
+test("does not fall back to an uncoordinated refresh when SharedWorker is unavailable", async () => {
+ vi.stubGlobal("SharedWorker", undefined);
+ await expect(refreshTokensInWorker()).rejects.toThrow();
+});
+
+for (const failure of ["error", "timeout"] as const) {
+ test(`startup ${failure} retries within the same shared refresh promise`, async () => {
+ vi.useFakeTimers();
+ const first = refreshTokensInWorker();
+ const rejected = vi.fn();
+ void first.catch(rejected);
+ expect(refreshTokensInWorker()).toBe(first);
+ const failedWorker = worker;
+ if (failure === "error") {
+ worker.dispatchEvent(new Event("error"));
+ } else {
+ await vi.advanceTimersByTimeAsync(35000);
+ }
+ expect(failedWorker.port.postMessage).not.toHaveBeenCalled();
+ expect(failedWorker.port.close).toHaveBeenCalledTimes(1);
+ worker = new TestWorker();
+ await vi.advanceTimersByTimeAsync(250);
+ expect(rejected).not.toHaveBeenCalled();
+ expect(refreshTokensInWorker()).toBe(first);
+ expect(construct).toHaveBeenCalledTimes(2);
+ expect(worker.port.postMessage).not.toHaveBeenCalled();
+ respond({ ready: true });
+ expect(worker.port.postMessage).toHaveBeenCalledExactlyOnceWith("refresh");
+ failedWorker.dispatchEvent(new Event("error"));
+ respond();
+ await first;
+ expect(rejected).not.toHaveBeenCalled();
+ const later = refreshTokensInWorker();
+ respond();
+ await later;
+ expect(worker.port.postMessage).toHaveBeenCalledTimes(2);
+ });
+}
+
+test("persistent startup failures reject after three attempts without refreshing", async () => {
+ vi.useFakeTimers();
+ const result = expect(refreshTokensInWorker()).rejects.toThrow(
+ "worker failed"
+ );
+ const failedWorkers = [];
+ for (let attempt = 1; attempt <= 3; attempt++) {
+ failedWorkers.push(worker);
+ worker.dispatchEvent(new Event("error"));
+ worker = new TestWorker();
+ await vi.advanceTimersByTimeAsync(250 * attempt);
+ }
+ await result;
+ expect(construct).toHaveBeenCalledTimes(3);
+ for (const failedWorker of failedWorkers) {
+ expect(failedWorker.port.close).toHaveBeenCalledTimes(1);
+ expect(failedWorker.port.postMessage).not.toHaveBeenCalled();
+ }
+});
diff --git a/frontend/src/api/refreshTokenSharedWorker.ts b/frontend/src/api/refreshTokenSharedWorker.ts
new file mode 100644
index 0000000000..7779e0e105
--- /dev/null
+++ b/frontend/src/api/refreshTokenSharedWorker.ts
@@ -0,0 +1,116 @@
+let worker: SharedWorker | undefined;
+let workerError: Error | undefined;
+let workerReady = false;
+let localPromise: Promise<void> | null = null;
+
+const WAIT_TIMEOUT_MS = 35000;
+const STARTUP_ATTEMPTS = 3;
+const STARTUP_RETRY_DELAY_MS = 250;
+
+/** Startup failed before this caller dispatched a refresh request. */
+export class WorkerStartupError extends Error {}
+
+/** Refresh shared session cookies through the same worker in every tab. */
+export function refreshTokensInWorker(): Promise<void> {
+ if (localPromise) {
+ return localPromise;
+ }
+ localPromise = refreshWithStartupRetry().finally(() => {
+ localPromise = null;
+ });
+ return localPromise;
+}
+
+async function refreshWithStartupRetry(): Promise<void> {
+ for (let attempt = 1; ; attempt++) {
+ try {
+ await refreshInWorker();
+ return;
+ } catch (error) {
+ if (
+ !(error instanceof WorkerStartupError) ||
+ attempt >= STARTUP_ATTEMPTS
+ ) {
+ throw error;
+ }
+ // Keep transient startup failures inside the shared promise: callers
+ // interpret a rejected refresh as an expired session.
+ await new Promise((resolve) =>
+ setTimeout(resolve, STARTUP_RETRY_DELAY_MS * attempt)
+ );
+ }
+ }
+}
+
+async function refreshInWorker(): Promise<void> {
+ if (workerError) throw workerError;
+ if (!worker) {
+ worker = new SharedWorker(
+ new URL("./refreshToken.worker.ts", import.meta.url),
+ {
+ type: "module",
+ name: "bb_token_refresh",
+ }
+ );
+ const startingWorker = worker;
+ worker.addEventListener("error", () => {
+ if (worker === startingWorker && workerReady) {
+ workerError = new Error("Session refresh worker failed");
+ }
+ });
+ worker.port.start();
+ }
+ const currentWorker = worker;
+ return new Promise<void>((resolve, reject) => {
+ const cleanup = () => {
+ clearTimeout(timeout);
+ currentWorker.port.removeEventListener("message", onMessage);
+ currentWorker.port.removeEventListener("messageerror", onFailure);
+ currentWorker.removeEventListener("error", onFailure);
+ };
+ const onFailure = () => {
+ cleanup();
+ const error = new Error("Session refresh worker failed");
+ if (workerReady) {
+ workerError ??= error;
+ } else {
+ // No refresh was dispatched before readiness, so retrying startup is safe.
+ currentWorker.port.close();
+ worker = undefined;
+ reject(new WorkerStartupError(error.message));
+ return;
+ }
+ reject(workerError ?? error);
+ };
+ const sendRefresh = () => {
+ clearTimeout(timeout);
+ timeout = setTimeout(onFailure, WAIT_TIMEOUT_MS);
+ try {
+ currentWorker.port.postMessage("refresh");
+ } catch {
+ onFailure();
+ }
+ };
+ const onMessage = (
+ event: MessageEvent<{ ready?: boolean; error?: string }>
+ ) => {
+ if (event.data.ready) {
+ if (!workerReady) {
+ workerReady = true;
+ sendRefresh();
+ }
+ return;
+ }
+ cleanup();
+ if (event.data.error) reject(new Error(event.data.error));
+ else resolve();
+ };
+ // After readiness, a timed-out worker may still be rotating cookies.
+ // Retrying could reuse the consumed token.
+ let timeout = setTimeout(onFailure, WAIT_TIMEOUT_MS);
+ currentWorker.port.addEventListener("message", onMessage);
+ currentWorker.port.addEventListener("messageerror", onFailure);
+ currentWorker.addEventListener("error", onFailure);
+ if (workerReady) sendRefresh();
+ });
+}
diff --git a/frontend/vite.config.test.ts b/frontend/vite.config.test.ts
new file mode 100644
index 0000000000..af1e06f449
--- /dev/null
+++ b/frontend/vite.config.test.ts
@@ -0,0 +1,55 @@
+// @vitest-environment node
+import { fileURLToPath } from "node:url";
+import { build } from "vite";
+import { expect, test } from "vitest";
+import config from "./vite.config";
+
+test("refresh worker keeps its URL across builds with different worker contents", async () => {
+ const bundles = [];
+ for (const version of ["old", "new"]) {
+ const result = await build({
+ configFile: false,
+ logLevel: "silent",
+ resolve: config.resolve,
+ worker: {
+ ...config.worker,
+ plugins: () => [
+ {
+ name: "worker-version-fixture",
+ transform(code, id) {
+ if (id.endsWith("/refreshToken.worker.ts")) {
+ return `${code}\nconsole.info(${JSON.stringify(version)});`;
+ }
+ },
+ },
+ ],
+ },
+ build: {
+ write: false,
+ rollupOptions: {
+ input: fileURLToPath(
+ new URL("./src/api/refreshTokenSharedWorker.ts", import.meta.url)
+ ),
+ preserveEntrySignatures: "strict",
+ },
+ },
+ });
+ if (Array.isArray(result) || !("output" in result)) {
+ throw new Error("Expected one production bundle");
+ }
+ bundles.push(result.output);
+ }
+
+ const workers = bundles.map((bundle) => {
+ const worker = bundle.find(
+ (output) => output.fileName === "refreshToken.worker.js"
+ );
+ expect(worker).toBeDefined();
+ return worker;
+ });
+ expect(workers[0]).not.toEqual(workers[1]);
+ const entries = bundles.map((bundle) =>
+ bundle.find((output) => output.type === "chunk" && output.isEntry)
+ );
+ expect(entries[0]).toEqual(entries[1]);
+});
diff --git a/frontend/vite.config.ts b/frontend/vite.config.ts
index 8c9d0c68b0..1b471ec38a 100644
--- a/frontend/vite.config.ts
+++ b/frontend/vite.config.ts
@@ -164,5 +164,15 @@ export default defineConfig({
},
worker: {
format: "es",
+ rollupOptions: {
+ output: {
+ // Old and new app tabs must connect to the same refresh coordinator.
+ // Keep its URL stable and outside the immutable /assets/ cache.
+ entryFileNames: (chunk) =>
+ chunk.name === "refreshToken.worker"
+ ? "refreshToken.worker.js"
+ : "assets/[name]-[hash].js",
+ },
+ },
},
});