Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

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.ts
new file mode 100644
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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}`;