Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
fix(auth): stop the jwt/refresh storm for anonymous visitors (#5143)
gbirmanb7b3b9b0c11b
diff --git a/apps/web/src/lib/core/util/fetchWithToken.spec.ts b/apps/web/src/lib/core/util/fetchWithToken.spec.tsnew file mode 100644index 0000000000..822cb08960--- /dev/null+++ b/apps/web/src/lib/core/util/fetchWithToken.spec.ts@@ -0,0 +1,169 @@+/**+ * @vitest-environment jsdom+ */++import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';++import {+ fetchToken,+ fetchWithToken,+ unsetTokenPromise,+} from './fetchWithToken';++const RESOURCE_URL = 'https://localhost/resource';++function jsonResponse(status: number, body: unknown = {}): Response {+ return {+ ok: status >= 200 && status < 300,+ status,+ json: () => Promise.resolve(body),+ headers: new Headers({ 'Content-Type': 'application/json' }),+ } as Response;+}++function deferred<T>() {+ let resolve!: (value: T) => void;+ const promise = new Promise<T>((r) => {+ resolve = r;+ });+ return { promise, resolve };+}++const tick = () => new Promise((r) => setTimeout(r, 0));++const isRefresh = (input: RequestInfo | URL) =>+ String(input).includes('/jwt/refresh');++describe('fetchWithToken refresh latch', () => {+ const originalFetch = global.fetch;+ const mockFetch = vi.fn<typeof fetch>();++ beforeEach(() => {+ unsetTokenPromise();+ global.fetch = mockFetch as typeof fetch;+ });++ afterEach(() => {+ global.fetch = originalFetch;+ mockFetch.mockReset();+ });++ const refreshCalls = () =>+ mockFetch.mock.calls.filter(([input]) => isRefresh(input)).length;++ test('fires at most one doomed refresh across sequential 401s', async () => {+ mockFetch.mockImplementation((input) =>+ Promise.resolve(isRefresh(input) ? jsonResponse(400) : jsonResponse(401))+ );++ for (let i = 0; i < 3; i++) {+ const result = await fetchWithToken<{ data: string }>(RESOURCE_URL);+ expect(result.isErr()).toBe(true);+ if (result.isErr()) {+ expect(result.error.some((e) => e.code === 'UNAUTHORIZED')).toBe(true);+ }+ }++ expect(refreshCalls()).toBe(1);+ });++ test('authenticated expired-token request still refreshes and retries', async () => {+ let refreshed = false;+ mockFetch.mockImplementation((input) => {+ if (isRefresh(input)) {+ refreshed = true;+ return Promise.resolve(jsonResponse(200));+ }+ return Promise.resolve(+ refreshed ? jsonResponse(200, { data: 'ok' }) : jsonResponse(401)+ );+ });++ const result = await fetchWithToken<{ data: string }>(RESOURCE_URL);++ expect(result.isOk()).toBe(true);+ if (result.isOk()) expect(result.value).toEqual({ data: 'ok' });+ expect(refreshCalls()).toBe(1);+ });++ test('a successful refresh does not latch subsequent 401s', async () => {+ let refreshCount = 0;+ mockFetch.mockImplementation((input) => {+ if (isRefresh(input)) {+ refreshCount++;+ return Promise.resolve(jsonResponse(200));+ }+ // Each resource call 401s, forcing a fresh refresh every time.+ return Promise.resolve(jsonResponse(401));+ });++ await fetchWithToken<{ data: string }>(RESOURCE_URL);+ await fetchWithToken<{ data: string }>(RESOURCE_URL);++ expect(refreshCount).toBe(2);+ });++ test('a transient refresh failure (500) does not latch', async () => {+ mockFetch.mockImplementation((input) =>+ Promise.resolve(isRefresh(input) ? jsonResponse(500) : jsonResponse(401))+ );++ await fetchWithToken<{ data: string }>(RESOURCE_URL);+ await fetchWithToken<{ data: string }>(RESOURCE_URL);++ expect(refreshCalls()).toBe(2);+ });++ test('unsetTokenPromise clears the latch so refresh is attempted again', async () => {+ mockFetch.mockImplementation((input) =>+ Promise.resolve(isRefresh(input) ? jsonResponse(400) : jsonResponse(401))+ );++ await fetchWithToken<{ data: string }>(RESOURCE_URL);+ expect(refreshCalls()).toBe(1);++ unsetTokenPromise();++ await fetchWithToken<{ data: string }>(RESOURCE_URL);+ expect(refreshCalls()).toBe(2);+ });++ test('a reset while a refresh is pending neither latches nor clears newer state', async () => {+ const pending = [deferred<Response>(), deferred<Response>()];+ let idx = 0;+ mockFetch.mockImplementation((input) => {+ if (isRefresh(input)) {+ const d = pending[idx++];+ return d ? d.promise : Promise.resolve(jsonResponse(200));+ }+ return Promise.resolve(jsonResponse(401));+ });++ // R1 starts and stays in-flight.+ const p1 = fetchToken();+ // A login-style reset happens while R1 is pending.+ unsetTokenPromise();+ // R2 starts under the new generation and also stays in-flight.+ const p2 = fetchToken();+ await tick();+ expect(refreshCalls()).toBe(2);++ // R1 fails under the stale generation.+ pending[0].resolve(jsonResponse(400));+ expect((await p1).isErr()).toBe(true);++ // R1's finally must not have cleared R2's tokenPromise: a call now dedupes+ // onto R2 instead of starting a third refresh.+ const p2b = fetchToken();+ await tick();+ expect(refreshCalls()).toBe(2);++ pending[1].resolve(jsonResponse(200));+ expect((await p2).isOk()).toBe(true);+ expect((await p2b).isOk()).toBe(true);++ // R1's stale failure must not have latched: a fresh 401 still refreshes.+ expect((await fetchToken()).isOk()).toBe(true);+ expect(refreshCalls()).toBe(3);+ });+});diff --git a/apps/web/src/lib/core/util/fetchWithToken.ts b/apps/web/src/lib/core/util/fetchWithToken.tsindex 1347ccdad3..e6db7c2fa0 100644--- a/apps/web/src/lib/core/util/fetchWithToken.ts+++ b/apps/web/src/lib/core/util/fetchWithToken.ts@@ -49,14 +49,28 @@ function fetchWithCredentials<);}-let tokenPromise: Promise<- Result<void, ResultError<FetchWithTokenErrorCode>[]>-> | null = null;+type TokenResult = Result<void, ResultError<FetchWithTokenErrorCode>[]>;-export async function fetchToken(): Promise<- Result<void, ResultError<FetchWithTokenErrorCode>[]>-> {+let tokenPromise: Promise<TokenResult> | null = null;++// Once /jwt/refresh fails because the session is not authenticated (400/401),+// cache that failure so subsequent 401s short-circuit instead of each firing+// another doomed refresh. An anonymous visitor on a public link otherwise+// triggers one refresh per authenticated app-chrome query. Cleared by+// unsetTokenPromise, which the login flows call on a session change.+let refreshUnavailable: TokenResult | null = null;++// Bumped on every reset. A refresh started before a reset carries the older+// generation, so once the session has moved on (e.g. a login) it can neither+// re-latch refreshUnavailable nor clear a newer tokenPromise on completion.+let refreshGeneration = 0;++export async function fetchToken(): Promise<TokenResult> {+ if (refreshUnavailable != null) {+ return refreshUnavailable;+ }if (tokenPromise == null) {+ const generation = refreshGeneration;tokenPromise = (async () => {try {const result = await fetchWithCredentials(@@ -72,12 +86,23 @@ export async function fetchToken(): Promise<);if (result.isErr()) {- return err(result.error);+ const failure = err(result.error);+ if (+ generation === refreshGeneration &&+ result.error.some(+ (e) => e.code === 'HTTP_ERROR' || e.code === 'UNAUTHORIZED'+ )+ ) {+ refreshUnavailable = failure;+ }+ return failure;}return ok(undefined);} finally {- tokenPromise = null;+ if (generation === refreshGeneration) {+ tokenPromise = null;+ }}})();}@@ -164,5 +189,7 @@ export async function fetchWithToken<* unsetTokenPromise();*/export function unsetTokenPromise() {+ refreshGeneration++;tokenPromise = null;+ refreshUnavailable = null;}diff --git a/apps/web/src/lib/service-clients/service-connection/websocket.ts b/apps/web/src/lib/service-clients/service-connection/websocket.tsindex 1e6d49d1c2..d0dc1f1188 100644--- a/apps/web/src/lib/service-clients/service-connection/websocket.ts+++ b/apps/web/src/lib/service-clients/service-connection/websocket.ts@@ -1,7 +1,7 @@import { createBlockEffect, inBlock } from '@core/block';import { ENABLE_BEARER_TOKEN_AUTH } from '@core/constant/featureFlags';import { SERVER_HOSTS } from '@core/constant/servers';-import { fetchToken, unsetTokenPromise } from '@core/util/fetchWithToken';+import { fetchToken } from '@core/util/fetchWithToken';import {ArrayQueue,createSocketEffect,@@ -34,8 +34,6 @@ async function resolveWsUrl() {return `${wsHost}/?macro-api-token=${apiToken}`;}- // Clear any cached token promise to force a fresh refresh on reconnect- unsetTokenPromise();await fetchToken();return wsHost;}