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(web): recover expired Macro API token cache (#6348)
KevinLau1db31b2ad619
diff --git a/apps/web/src/lib/service-clients/service-auth/client.test.ts b/apps/web/src/lib/service-clients/service-auth/client.test.tsnew file mode 100644index 0000000000..1e63c21679--- /dev/null+++ b/apps/web/src/lib/service-clients/service-auth/client.test.ts@@ -0,0 +1,25 @@+/**+ * @vitest-environment jsdom+ */++import { describe, expect, test } from 'vitest';+import { getExpiresAt } from './client';++function jwt(exp: unknown) {+ const payload = btoa(JSON.stringify({ exp }));+ return `header.${payload}.signature`;+}++describe('getExpiresAt', () => {+ test('converts a numeric exp from seconds to milliseconds', () => {+ const exp = Math.floor(Date.now() / 1000) + 3600;++ expect(getExpiresAt(jwt(exp))).toBe(exp * 1000);+ });++ test('rejects an array-valued exp', () => {+ const exp = [Math.floor(Date.now() / 1000) + 3600];++ expect(getExpiresAt(jwt(exp))).toBe(0);+ });+});diff --git a/apps/web/src/lib/service-clients/service-auth/client.ts b/apps/web/src/lib/service-clients/service-auth/client.tsindex d3f6061eb1..fb5c8f09ac 100644--- a/apps/web/src/lib/service-clients/service-auth/client.ts+++ b/apps/web/src/lib/service-clients/service-auth/client.ts@@ -88,10 +88,24 @@ const [accessTokenData, setAccessTokenData] = makePersisted(});-function getExpiresAt(token: string) {+export function getExpiresAt(token: string) {try {- const payload = JSON.parse(atob(token.split('.')[1]));- return payload.exp;+ const payload: unknown = JSON.parse(atob(token.split('.')[1]));+ if (+ typeof payload !== 'object' ||+ payload === null ||+ !('exp' in payload)+ ) {+ return 0;+ }++ const expValue = payload.exp;+ if (typeof expValue !== 'number' && typeof expValue !== 'string') {+ return 0;+ }++ const exp = Number(expValue) * 1000;+ return Number.isFinite(exp) ? exp : 0;} catch {return 0;}diff --git a/apps/web/src/lib/service-clients/service-auth/fetch.test.ts b/apps/web/src/lib/service-clients/service-auth/fetch.test.tsnew file mode 100644index 0000000000..8f5ba06084--- /dev/null+++ b/apps/web/src/lib/service-clients/service-auth/fetch.test.ts@@ -0,0 +1,146 @@+/**+ * @vitest-environment jsdom+ */++import { err, ok } from 'neverthrow';+import { beforeEach, describe, expect, test, vi } from 'vitest';++const macroApiToken = vi.fn();++vi.mock('./client', () => ({+ authServiceClient: { macroApiToken },+ getExpiresAt: (token: string) => {+ try {+ const payload: unknown = JSON.parse(atob(token.split('.')[1]));+ if (+ typeof payload !== 'object' ||+ payload === null ||+ !('exp' in payload)+ ) {+ return 0;+ }++ const expValue = payload.exp;+ if (typeof expValue !== 'number' && typeof expValue !== 'string') {+ return 0;+ }++ const exp = Number(expValue) * 1000;+ return Number.isFinite(exp) ? exp : 0;+ } catch {+ return 0;+ }+ },+}));++function jwt(exp: unknown) {+ const payload = btoa(JSON.stringify({ exp }));+ return `header.${payload}.signature`;+}++describe('getMacroApiToken', () => {+ beforeEach(() => {+ vi.resetModules();+ macroApiToken.mockReset();+ });++ test('reuses an unexpired cached token', async () => {+ const token = jwt(Math.floor(Date.now() / 1000) + 3600);+ macroApiToken.mockResolvedValue(ok({ macro_api_token: token }));+ const { getMacroApiToken } = await import('./fetch');++ await expect(getMacroApiToken()).resolves.toBe(token);+ await expect(getMacroApiToken()).resolves.toBe(token);++ expect(macroApiToken).toHaveBeenCalledTimes(1);+ });++ test('refreshes an expired cached token', async () => {+ const expired = jwt(Math.floor(Date.now() / 1000) - 60);+ const fresh = jwt(Math.floor(Date.now() / 1000) + 3600);+ macroApiToken+ .mockResolvedValueOnce(ok({ macro_api_token: expired }))+ .mockResolvedValueOnce(ok({ macro_api_token: fresh }));+ const { getMacroApiToken } = await import('./fetch');++ await expect(getMacroApiToken()).resolves.toBe(expired);+ await expect(getMacroApiToken()).resolves.toBe(fresh);++ expect(macroApiToken).toHaveBeenCalledTimes(2);+ });++ test('refreshes a cached token with a non-scalar exp', async () => {+ const malformed = jwt([Math.floor(Date.now() / 1000) + 3600]);+ const fresh = jwt(Math.floor(Date.now() / 1000) + 3600);+ macroApiToken+ .mockResolvedValueOnce(ok({ macro_api_token: malformed }))+ .mockResolvedValueOnce(ok({ macro_api_token: fresh }));+ const { getMacroApiToken } = await import('./fetch');++ await expect(getMacroApiToken()).resolves.toBe(malformed);+ await expect(getMacroApiToken()).resolves.toBe(fresh);++ expect(macroApiToken).toHaveBeenCalledTimes(2);+ });++ test('deduplicates concurrent requests when the cache is empty', async () => {+ const token = jwt(Math.floor(Date.now() / 1000) + 3600);+ let release!: () => void;+ const gate = new Promise<void>((resolve) => {+ release = resolve;+ });+ macroApiToken.mockImplementation(async () => {+ await gate;+ return ok({ macro_api_token: token });+ });+ const { getMacroApiToken } = await import('./fetch');++ const first = getMacroApiToken();+ const second = getMacroApiToken();++ expect(macroApiToken).toHaveBeenCalledTimes(1);+ release();+ await expect(Promise.all([first, second])).resolves.toEqual([token, token]);+ });++ test('deduplicates concurrent refreshes of an expired cached token', async () => {+ const expired = jwt(Math.floor(Date.now() / 1000) - 60);+ const fresh = jwt(Math.floor(Date.now() / 1000) + 3600);+ macroApiToken.mockResolvedValueOnce(ok({ macro_api_token: expired }));+ const { getMacroApiToken } = await import('./fetch');++ await expect(getMacroApiToken()).resolves.toBe(expired);++ let release!: () => void;+ const gate = new Promise<void>((resolve) => {+ release = resolve;+ });+ macroApiToken.mockImplementationOnce(async () => {+ await gate;+ return ok({ macro_api_token: fresh });+ });++ const first = getMacroApiToken();+ const second = getMacroApiToken();++ await Promise.resolve();+ expect(macroApiToken).toHaveBeenCalledTimes(2);+ release();+ await expect(Promise.all([first, second])).resolves.toEqual([fresh, fresh]);+ });++ test('does not permanently cache a rejected token request', async () => {+ const fresh = jwt(Math.floor(Date.now() / 1000) + 3600);+ macroApiToken+ .mockResolvedValueOnce(+ err([{ code: 'UNAUTHORIZED' as const, message: 'Unauthorized access' }])+ )+ .mockResolvedValueOnce(ok({ macro_api_token: fresh }));+ const { getMacroApiToken } = await import('./fetch');++ await expect(getMacroApiToken()).rejects.toBeDefined();+ await expect(getMacroApiToken()).resolves.toBe(fresh);++ expect(macroApiToken).toHaveBeenCalledTimes(2);+ });+});diff --git a/apps/web/src/lib/service-clients/service-auth/fetch.ts b/apps/web/src/lib/service-clients/service-auth/fetch.tsindex 34bbe3da23..e24021e45a 100644--- a/apps/web/src/lib/service-clients/service-auth/fetch.ts+++ b/apps/web/src/lib/service-clients/service-auth/fetch.ts@@ -8,19 +8,34 @@ import {type TextResponse,} from '@core/util/safeFetch';import { err, ok, type Result } from 'neverthrow';-import { authServiceClient } from './client';+import { authServiceClient, getExpiresAt } from './client';function isExpired(token: string) {- try {- const payload = JSON.parse(atob(token.split('.')[1]));- const exp = payload.exp * 1000;- return Date.now() / 1000 > exp;- } catch {- return true;- }+ const expiresAt = getExpiresAt(token);+ return expiresAt <= 0 || Date.now() >= expiresAt;}let macroApiTokenPromise: Promise<string> | null = null;++function requestMacroApiToken() {+ const promise = authServiceClient.macroApiToken().then((result) => {+ if (result.isErr()) {+ throw result.error;+ }+ return result.value.macro_api_token;+ });++ macroApiTokenPromise = promise;+ void promise.catch(() => {+ // A failed request must not poison the cache permanently. Keep the+ // identity check so an older rejection cannot clear a newer request.+ if (macroApiTokenPromise === promise) {+ macroApiTokenPromise = null;+ }+ });+ return promise;+}+export async function getMacroApiToken() {if (LOCAL_ONLY) {const apiToken = import.meta.env.__LOCAL_JWT__;@@ -28,21 +43,25 @@ export async function getMacroApiToken() {return apiToken;}}- const apiToken = await macroApiTokenPromise;- if (apiToken && !isExpired(apiToken)) {++ const cachedPromise = macroApiTokenPromise;+ if (!cachedPromise) {+ return requestMacroApiToken();+ }++ const apiToken = await cachedPromise;+ if (!isExpired(apiToken)) {return apiToken;}- macroApiTokenPromise = new Promise((resolve, reject) =>- authServiceClient.macroApiToken().then((result) => {- if (result.isErr()) {- reject(result.error);- } else {- resolve(result.value.macro_api_token);- }- })- );- return macroApiTokenPromise;+ // Another caller may already have replaced the expired entry while this+ // caller was suspended awaiting it. Reuse that replacement instead of+ // issuing a duplicate request.+ if (macroApiTokenPromise !== cachedPromise) {+ return getMacroApiToken();+ }++ return requestMacroApiToken();}type TextContentType = `text/${string}`;