@mintlify/cli 4.0.1813 → 4.1.1

package/__test__/agent.test.ts

@@ -1,64 +0,0 @@
-import { detectAgent, isCI } from '../src/agent.js';
-
-const originalIsTTY = process.stdout.isTTY;
-
-afterEach(() => {
-  process.stdout.isTTY = originalIsTTY;
-});
-
-describe('detectAgent', () => {
-  it('returns undefined with no agent env', () => {
-    expect(detectAgent({})).toBeUndefined();
-  });
-
-  it.each([
-    [{ CLAUDECODE: '1' }, 'claude_code'],
-    [{ TERM_PROGRAM: 'claude' }, 'claude_code'],
-    [{ CLAUDECODE: '1', CLAUDE_CODE_IS_COWORK: '1' }, 'cowork'],
-    [{ CODEX_THREAD_ID: 'abc' }, 'codex_cli'],
-    [{ GEMINI_CLI: '1' }, 'gemini_cli'],
-    [{ CURSOR_AGENT: '1' }, 'cursor-cli'],
-    [{ OPENCODE: '1' }, 'open_code'],
-    [{ PATH: '/usr/bin:/home/me/.pi/agent/bin' }, 'pi'],
-    [{ EDITOR: '/opt/devin/bin/code' }, 'devin'],
-  ])('detects %o as %s', (env, expected) => {
-    expect(detectAgent(env)).toBe(expected);
-  });
-
-  it('prefers explicit AI_AGENT and AGENT', () => {
-    expect(detectAgent({ AI_AGENT: 'Amp', CLAUDECODE: '1' })).toBe('amp');
-    expect(detectAgent({ AGENT: 'goose' })).toBe('goose');
-  });
-
-  it('prefers CLI agents over IDE hosts', () => {
-    process.stdout.isTTY = false;
-    expect(detectAgent({ CLAUDECODE: '1', CURSOR_TRACE_ID: 'x' })).toBe('claude_code');
-    expect(detectAgent({ CURSOR_TRACE_ID: 'x' })).toBe('cursor');
-  });
-
-  it('ignores IDE and config markers when a human is at a TTY', () => {
-    process.stdout.isTTY = true;
-    expect(
-      detectAgent({
-        CURSOR_TRACE_ID: 'x',
-        REPL_ID: 'y',
-        TERM_PROGRAM: 'kiro',
-        GOOSE_PROVIDER: 'openai',
-        COPILOT_MODEL: 'gpt',
-        OPENCODE_CLIENT: 'desktop',
-      })
-    ).toBeUndefined();
-  });
-});
-
-describe('isCI', () => {
-  it.each([
-    [{}, false],
-    [{ CI: 'true' }, true],
-    [{ CI: '1' }, true],
-    [{ CI: 'false' }, false],
-    [{ CI: '0' }, false],
-  ])('%o -> %s', (env, expected) => {
-    expect(isCI(env)).toBe(expected);
-  });
-});

package/__test__/analytics/client.test.ts

@@ -1,180 +0,0 @@
-import {
-  getAssistantThread,
-  getFeedback,
-  getFeedbackByPage,
-  getBuckets,
-  getBucketThreads,
-  getConversations,
-  getKpi,
-  getSearches,
-  getViews,
-  getVisitors,
-} from '../../src/analytics/client.js';
-
-vi.mock('../../src/keyring.js', () => ({
-  getAccessToken: vi.fn().mockResolvedValue(null),
-  getRefreshToken: vi.fn().mockResolvedValue(null),
-  storeCredentials: vi.fn().mockResolvedValue(undefined),
-}));
-
-const mockFetch = vi.fn();
-global.fetch = mockFetch;
-
-beforeEach(() => {
-  vi.stubEnv('MINTLIFY_SESSION_TOKEN', 'test-token');
-  vi.stubEnv('MINTLIFY_API_URL', 'http://test-server:5000');
-  mockFetch.mockReset();
-});
-
-afterEach(() => {
-  vi.unstubAllEnvs();
-});
-
-function mockOk(data: unknown) {
-  mockFetch.mockResolvedValueOnce({
-    ok: true,
-    status: 200,
-    json: () => Promise.resolve(data),
-  });
-}
-
-function mockError(status: number, body: string) {
-  mockFetch.mockResolvedValueOnce({
-    ok: false,
-    status,
-    statusText: 'Bad Request',
-    text: () => Promise.resolve(body),
-  });
-}
-
-function calledUrl(): string {
-  const arg = mockFetch.mock.calls[0]![0];
-  return typeof arg === 'string' ? arg : String(arg);
-}
-
-function calledUrlObj(): URL {
-  return new URL(calledUrl());
-}
-
-describe('client auth', () => {
-  it('throws when no session token is set', async () => {
-    vi.stubEnv('MINTLIFY_SESSION_TOKEN', '');
-    await expect(getFeedback({ dateFrom: '2024-01-01', dateTo: '2024-01-31' })).rejects.toThrow(
-      'Not authenticated'
-    );
-  });
-
-  it('sends session cookie header', async () => {
-    mockOk({ feedback: [], nextCursor: null, hasMore: false });
-    await getFeedback({ dateFrom: '2024-01-01', dateTo: '2024-01-31' }, 'test');
-    expect(mockFetch).toHaveBeenCalledWith(
-      expect.any(String),
-      expect.objectContaining({
-        headers: expect.objectContaining({
-          Authorization: 'Bearer test-token',
-        }),
-      })
-    );
-  });
-});
-
-describe('client request handling', () => {
-  it('throws on API error', async () => {
-    mockError(400, 'Invalid params');
-    await expect(getFeedback({ dateFrom: '2024-01-01', dateTo: '2024-01-31' })).rejects.toThrow(
-      'API error (400): Invalid params'
-    );
-  });
-
-  it('passes subdomain as query param when provided', async () => {
-    mockOk({ feedback: [], nextCursor: null, hasMore: false });
-    await getFeedback({ dateFrom: '2024-01-01', dateTo: '2024-01-31' }, 'my-docs');
-    expect(calledUrlObj().searchParams.get('subdomain')).toBe('my-docs');
-    expect(calledUrlObj().pathname).toBe('/api/cli/analytics/feedback');
-  });
-
-  it('omits subdomain param when not provided', async () => {
-    mockOk({ feedback: [], nextCursor: null, hasMore: false });
-    await getFeedback({ dateFrom: '2024-01-01', dateTo: '2024-01-31' });
-    expect(calledUrlObj().searchParams.has('subdomain')).toBe(false);
-  });
-
-  it('sets query params and omits undefined values', async () => {
-    mockOk({ feedback: [], nextCursor: null, hasMore: false });
-    await getFeedback({
-      dateFrom: '2024-01-01',
-      dateTo: '2024-01-31',
-      limit: 10,
-      cursor: undefined,
-    });
-    expect(calledUrlObj().searchParams.get('dateFrom')).toBe('2024-01-01');
-    expect(calledUrlObj().searchParams.get('limit')).toBe('10');
-    expect(calledUrlObj().searchParams.has('cursor')).toBe(false);
-  });
-});
-
-describe('endpoint paths', () => {
-  it('getKpi', async () => {
-    mockOk({ humanVisitors: 0 });
-    await getKpi({ dateFrom: '2024-01-01', dateTo: '2024-01-31' }, 'docs');
-    expect(calledUrlObj().pathname).toBe('/api/cli/analytics/kpi');
-    expect(calledUrlObj().searchParams.get('subdomain')).toBe('docs');
-  });
-
-  it('getFeedbackByPage', async () => {
-    mockOk({ feedback: [], hasMore: false });
-    await getFeedbackByPage({ dateFrom: '2024-01-01', dateTo: '2024-01-31' }, 'docs');
-    expect(calledUrlObj().pathname).toBe('/api/cli/analytics/feedback/by-page');
-  });
-
-  it('getConversations', async () => {
-    mockOk({ conversations: [], nextCursor: null, hasMore: false });
-    await getConversations({ dateFrom: '2024-01-01', dateTo: '2024-01-31' }, 'docs');
-    expect(calledUrlObj().pathname).toBe('/api/cli/analytics/assistant');
-  });
-
-  it('getAssistantThread', async () => {
-    mockOk({ threadId: 'thread-123', createdAt: '2024-01-01', messages: [] });
-    await getAssistantThread('thread/123', 'docs');
-    expect(calledUrlObj().pathname).toBe('/api/cli/analytics/assistant/threads/thread%2F123');
-    expect(calledUrlObj().searchParams.get('subdomain')).toBe('docs');
-  });
-
-  it('getSearches', async () => {
-    mockOk({ searches: [], totalSearches: 0, nextCursor: null });
-    await getSearches({ dateFrom: '2024-01-01', dateTo: '2024-01-31' }, 'docs');
-    expect(calledUrlObj().pathname).toBe('/api/cli/analytics/searches');
-  });
-
-  it('getViews', async () => {
-    mockOk({ totals: {}, views: [], hasMore: false });
-    await getViews({ dateFrom: '2024-01-01', dateTo: '2024-01-31' }, 'docs');
-    expect(calledUrlObj().pathname).toBe('/api/cli/analytics/views');
-  });
-
-  it('getVisitors', async () => {
-    mockOk({ totals: {}, visitors: [], hasMore: false });
-    await getVisitors({ dateFrom: '2024-01-01', dateTo: '2024-01-31' }, 'docs');
-    expect(calledUrlObj().pathname).toBe('/api/cli/analytics/visitors');
-  });
-
-  it('getBuckets', async () => {
-    mockOk({ data: [], pagination: { total: 0 } });
-    await getBuckets({ dateFrom: '2024-01-01', dateTo: '2024-01-31' }, 'docs');
-    expect(calledUrlObj().pathname).toBe('/api/cli/analytics/conversations/buckets');
-    expect(calledUrlObj().searchParams.get('subdomain')).toBe('docs');
-  });
-
-  it('getBucketThreads', async () => {
-    mockOk({ data: [], pagination: { total: 0, hasMore: false, nextCursor: null } });
-    await getBucketThreads(
-      'bucket-123',
-      { dateFrom: '2024-01-01', limit: 25, cursor: 'next-thread' },
-      'docs'
-    );
-    expect(calledUrlObj().pathname).toBe('/api/cli/analytics/conversations/buckets/bucket-123');
-    expect(calledUrlObj().searchParams.get('subdomain')).toBe('docs');
-    expect(calledUrlObj().searchParams.get('limit')).toBe('25');
-    expect(calledUrlObj().searchParams.get('cursor')).toBe('next-thread');
-  });
-});

package/__test__/analytics/dates.test.ts

@@ -1,12 +0,0 @@
-import { formatLocalDate } from '../../src/analytics/dates.js';
-
-describe('formatLocalDate', () => {
-  it('formats the local calendar date without converting to UTC', () => {
-    const date = new Date(2024, 0, 2, 23, 30);
-    expect(formatLocalDate(date)).toBe('2024-01-02');
-  });
-
-  it('pads single-digit months and days', () => {
-    expect(formatLocalDate(new Date(2024, 8, 7))).toBe('2024-09-07');
-  });
-});

package/__test__/analytics/filters.test.ts

@@ -1,116 +0,0 @@
-import {
-  filterConversationResponse,
-  filterFeedbackByPageResponse,
-  filterFeedbackResponse,
-  filterSearchResponse,
-} from '../../src/analytics/filters.js';
-import type {
-  ConversationResponse,
-  FeedbackByPageResponse,
-  FeedbackResponse,
-  SearchResponse,
-} from '../../src/analytics/types.js';
-
-describe('analytics response filters', () => {
-  it('returns a search response whose JSON rows match query and page filters', () => {
-    const data: SearchResponse = {
-      searches: [
-        {
-          searchQuery: 'Deploy a site',
-          hits: 5,
-          ctr: 40,
-          topClickedPage: '/deploy',
-          lastSearchedAt: '2024-01-01T00:00:00Z',
-        },
-        {
-          searchQuery: 'Deploy locally',
-          hits: 3,
-          ctr: 20,
-          topClickedPage: '/development',
-          lastSearchedAt: '2024-01-02T00:00:00Z',
-        },
-        {
-          searchQuery: 'Authentication',
-          hits: 2,
-          ctr: 10,
-          topClickedPage: '/auth',
-          lastSearchedAt: '2024-01-03T00:00:00Z',
-        },
-      ],
-      totalSearches: 10,
-      nextCursor: null,
-    };
-
-    expect(filterSearchResponse(data, { query: 'deploy', page: '/deploy' }).searches).toEqual([
-      data.searches[0],
-    ]);
-  });
-
-  it('filters grouped feedback in the returned response', () => {
-    const data: FeedbackByPageResponse = {
-      feedback: [
-        { path: '/guide', thumbsUp: 1, thumbsDown: 0, code: 0, total: 1 },
-        { path: '/api', thumbsUp: 0, thumbsDown: 1, code: 0, total: 1 },
-      ],
-      hasMore: false,
-    };
-
-    expect(filterFeedbackByPageResponse(data, '/guide').feedback).toEqual([data.feedback[0]]);
-  });
-
-  it('filters individual feedback in the returned response', () => {
-    const data: FeedbackResponse = {
-      feedback: [
-        {
-          id: '1',
-          path: '/guide',
-          comment: null,
-          createdAt: null,
-          source: 'contextual',
-          status: 'pending',
-        },
-        {
-          id: '2',
-          path: '/api',
-          comment: null,
-          createdAt: null,
-          source: 'contextual',
-          status: 'pending',
-        },
-      ],
-      nextCursor: null,
-      hasMore: false,
-    };
-
-    expect(filterFeedbackResponse(data, '/guide').feedback).toEqual([data.feedback[0]]);
-  });
-
-  it('filters conversations in the returned response', () => {
-    const data: ConversationResponse = {
-      conversations: [
-        {
-          id: '1',
-          timestamp: '2024-01-01T00:00:00Z',
-          query: 'Guide question',
-          response: 'Answer',
-          sources: [{ title: 'Guide', url: 'https://docs.example.com/guide' }],
-          queryCategory: null,
-        },
-        {
-          id: '2',
-          timestamp: '2024-01-02T00:00:00Z',
-          query: 'API question',
-          response: 'Answer',
-          sources: [{ title: 'API', url: 'https://docs.example.com/api' }],
-          queryCategory: null,
-        },
-      ],
-      nextCursor: null,
-      hasMore: false,
-    };
-
-    expect(filterConversationResponse(data, '/guide').conversations).toEqual([
-      data.conversations[0],
-    ]);
-  });
-});

package/__test__/analytics/format.test.ts

@@ -1,137 +0,0 @@
-import { num, pct, truncate } from '../../src/analytics/format.js';
-import {
-  formatBarChart,
-  formatPlainTable,
-  formatPrettyTable,
-  resolveFormat,
-} from '../../src/analytics/output.js';
-import * as helpers from '../../src/helpers.js';
-
-afterEach(() => {
-  vi.restoreAllMocks();
-});
-
-describe('num', () => {
-  it('formats numbers with locale separators', () => {
-    expect(num(0)).toBe('0');
-    expect(num(1234)).toBe('1,234');
-    expect(num(1000000)).toBe('1,000,000');
-  });
-});
-
-describe('pct', () => {
-  it('returns percentage string', () => {
-    expect(pct(1, 4)).toBe('25.0%');
-    expect(pct(1, 3)).toBe('33.3%');
-  });
-
-  it('returns dash when total is zero', () => {
-    expect(pct(0, 0)).toBe('\u2014');
-  });
-});
-
-describe('truncate', () => {
-  it('returns short strings unchanged', () => {
-    expect(truncate('hello', 10)).toBe('hello');
-  });
-
-  it('truncates long strings with ellipsis', () => {
-    expect(truncate('hello world', 6)).toBe('hello\u2026');
-  });
-
-  it('returns string unchanged when exactly at max', () => {
-    expect(truncate('hello', 5)).toBe('hello');
-  });
-});
-
-describe('formatPrettyTable', () => {
-  it('returns dim message for empty rows', () => {
-    const result = formatPrettyTable(['A', 'B'], []);
-    expect(result).toContain('No data found');
-  });
-
-  it('formats headers and rows with aligned columns', () => {
-    const result = formatPrettyTable(
-      ['Name', 'Count'],
-      [
-        ['foo', '10'],
-        ['barbaz', '5'],
-      ]
-    );
-    const lines = result.split('\n');
-    expect(lines).toHaveLength(4);
-    expect(lines[2]).toContain('foo');
-    expect(lines[3]).toContain('barbaz');
-  });
-});
-
-describe('formatPlainTable', () => {
-  it('returns empty string for empty rows', () => {
-    expect(formatPlainTable(['A', 'B'], [])).toBe('');
-  });
-
-  it('formats with tab separation and uppercase headers', () => {
-    const result = formatPlainTable(
-      ['Name', 'Count'],
-      [
-        ['foo', '10'],
-        ['bar', '5'],
-      ]
-    );
-    const lines = result.split('\n');
-    expect(lines[0]).toContain('NAME');
-    expect(lines[0]).toContain('\t');
-    expect(lines[1]).toContain('foo');
-  });
-});
-
-describe('resolveFormat', () => {
-  it('returns json when AI mode is active', () => {
-    vi.spyOn(helpers, 'isAI').mockReturnValue(true);
-    expect(resolveFormat({})).toBe('json');
-  });
-
-  it('returns specified format', () => {
-    vi.spyOn(helpers, 'isAI').mockReturnValue(true);
-    expect(resolveFormat({ format: 'plain' })).toBe('plain');
-    expect(resolveFormat({ format: 'json' })).toBe('json');
-    expect(resolveFormat({ format: 'graph' })).toBe('graph');
-  });
-
-  it('defaults to plain', () => {
-    vi.spyOn(helpers, 'isAI').mockReturnValue(false);
-    expect(resolveFormat({})).toBe('plain');
-  });
-});
-
-describe('formatBarChart', () => {
-  it('returns dim message for empty items', () => {
-    expect(formatBarChart([])).toContain('No data found');
-  });
-
-  it('renders bars with labels and values', () => {
-    const result = formatBarChart([
-      { label: 'Foo', value: 10 },
-      { label: 'Bar', value: 5 },
-    ]);
-    const lines = result.split('\n');
-    expect(lines).toHaveLength(2);
-    expect(lines[0]).toContain('Foo');
-    expect(lines[0]).toContain('10');
-    expect(lines[0]).toContain('\u2588');
-    expect(lines[1]).toContain('Bar');
-    expect(lines[1]).toContain('5');
-  });
-
-  it('scales bars relative to max value', () => {
-    const result = formatBarChart([
-      { label: 'Big', value: 100 },
-      { label: 'Small', value: 10 },
-    ]);
-    const bigBar = result.split('\n')[0]!;
-    const smallBar = result.split('\n')[1]!;
-    const bigBlocks = (bigBar.match(/\u2588/g) || []).length;
-    const smallBlocks = (smallBar.match(/\u2588/g) || []).length;
-    expect(bigBlocks).toBeGreaterThan(smallBlocks);
-  });
-});

package/__test__/authenticatedFetch.test.ts

@@ -1,182 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-import { authenticatedFetch } from '../src/authenticatedFetch.js';
-
-const mockGetAccessToken = vi.fn();
-const mockGetRefreshToken = vi.fn();
-const mockStoreCredentials = vi.fn();
-
-vi.mock('../src/keyring.js', () => ({
-  getAccessToken: (...args: unknown[]) => mockGetAccessToken(...args),
-  getRefreshToken: (...args: unknown[]) => mockGetRefreshToken(...args),
-  storeCredentials: (...args: unknown[]) => mockStoreCredentials(...args),
-}));
-
-const mockFetch = vi.fn();
-global.fetch = mockFetch;
-
-function makeResponse(status: number, body: unknown = {}) {
-  return {
-    ok: status >= 200 && status < 300,
-    status,
-    statusText: status === 401 ? 'Unauthorized' : 'OK',
-    json: () => Promise.resolve(body),
-    text: () => Promise.resolve(JSON.stringify(body)),
-  };
-}
-
-describe('authenticatedFetch', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockFetch.mockReset();
-    vi.stubEnv('MINTLIFY_SESSION_TOKEN', '');
-  });
-
-  afterEach(() => {
-    vi.unstubAllEnvs();
-  });
-
-  it('sends access token from keyring', async () => {
-    mockGetAccessToken.mockResolvedValue('access-123');
-    mockFetch.mockResolvedValueOnce(makeResponse(200, { ok: true }));
-
-    await authenticatedFetch('http://test/api');
-
-    expect(mockFetch).toHaveBeenCalledWith('http://test/api', {
-      headers: { Authorization: 'Bearer access-123' },
-    });
-  });
-
-  it('falls back to MINTLIFY_SESSION_TOKEN env var', async () => {
-    mockGetAccessToken.mockResolvedValue(null);
-    vi.stubEnv('MINTLIFY_SESSION_TOKEN', 'env-token');
-    mockFetch.mockResolvedValueOnce(makeResponse(200));
-
-    await authenticatedFetch('http://test/api');
-
-    expect(mockFetch).toHaveBeenCalledWith('http://test/api', {
-      headers: { Authorization: 'Bearer env-token' },
-    });
-  });
-
-  it('throws when no token is available', async () => {
-    mockGetAccessToken.mockResolvedValue(null);
-
-    await expect(authenticatedFetch('http://test/api')).rejects.toThrow('Not authenticated');
-  });
-
-  it('refreshes token on 401 and retries', async () => {
-    mockGetAccessToken.mockResolvedValue('expired-token');
-    mockGetRefreshToken.mockResolvedValue('refresh-123');
-    mockStoreCredentials.mockResolvedValue(undefined);
-
-    mockFetch
-      .mockResolvedValueOnce(makeResponse(401))
-      .mockResolvedValueOnce(
-        makeResponse(200, {
-          access_token: 'new-access',
-          refresh_token: 'new-refresh',
-          token_type: 'bearer',
-          expires_in: 3600,
-        })
-      )
-      .mockResolvedValueOnce(makeResponse(200, { ok: true }));
-
-    const res = await authenticatedFetch('http://test/api');
-
-    expect(res.status).toBe(200);
-    expect(mockFetch).toHaveBeenCalledTimes(3);
-    expect(mockFetch).toHaveBeenLastCalledWith('http://test/api', {
-      headers: { Authorization: 'Bearer new-access' },
-    });
-  });
-
-  it('falls back to env token when refresh fails', async () => {
-    mockGetAccessToken.mockResolvedValue('expired-token');
-    mockGetRefreshToken.mockResolvedValue('bad-refresh');
-    vi.stubEnv('MINTLIFY_SESSION_TOKEN', 'env-token');
-
-    mockFetch
-      .mockResolvedValueOnce(makeResponse(401))
-      .mockResolvedValueOnce(makeResponse(400, { error: 'invalid_grant' }))
-      .mockResolvedValueOnce(makeResponse(200, { ok: true }));
-
-    const res = await authenticatedFetch('http://test/api');
-
-    expect(res.status).toBe(200);
-    expect(mockFetch).toHaveBeenCalledTimes(3);
-    expect(mockFetch).toHaveBeenLastCalledWith('http://test/api', {
-      headers: { Authorization: 'Bearer env-token' },
-    });
-  });
-
-  it('returns original 401 when refresh fails and no env token', async () => {
-    mockGetAccessToken.mockResolvedValue('expired-token');
-    mockGetRefreshToken.mockResolvedValue('bad-refresh');
-
-    mockFetch
-      .mockResolvedValueOnce(makeResponse(401))
-      .mockResolvedValueOnce(makeResponse(400, { error: 'invalid_grant' }));
-
-    const res = await authenticatedFetch('http://test/api');
-
-    expect(res.status).toBe(401);
-    expect(mockFetch).toHaveBeenCalledTimes(2);
-  });
-
-  it('falls back to env token when no refresh token exists', async () => {
-    mockGetAccessToken.mockResolvedValue('expired-token');
-    mockGetRefreshToken.mockResolvedValue(null);
-    vi.stubEnv('MINTLIFY_SESSION_TOKEN', 'env-token');
-
-    mockFetch
-      .mockResolvedValueOnce(makeResponse(401))
-      .mockResolvedValueOnce(makeResponse(200, { ok: true }));
-
-    const res = await authenticatedFetch('http://test/api');
-
-    expect(res.status).toBe(200);
-    expect(mockFetch).toHaveBeenCalledTimes(2);
-    expect(mockFetch).toHaveBeenLastCalledWith('http://test/api', {
-      headers: { Authorization: 'Bearer env-token' },
-    });
-  });
-
-  it('returns original 401 when no refresh token and no env token', async () => {
-    mockGetAccessToken.mockResolvedValue('expired-token');
-    mockGetRefreshToken.mockResolvedValue(null);
-
-    mockFetch.mockResolvedValueOnce(makeResponse(401));
-
-    const res = await authenticatedFetch('http://test/api');
-
-    expect(res.status).toBe(401);
-    expect(mockFetch).toHaveBeenCalledTimes(1);
-  });
-
-  it('does not attempt refresh when only env token is available', async () => {
-    mockGetAccessToken.mockResolvedValue(null);
-    vi.stubEnv('MINTLIFY_SESSION_TOKEN', 'env-token');
-
-    mockFetch.mockResolvedValueOnce(makeResponse(401));
-
-    const res = await authenticatedFetch('http://test/api');
-
-    expect(res.status).toBe(401);
-    expect(mockGetRefreshToken).not.toHaveBeenCalled();
-    expect(mockFetch).toHaveBeenCalledTimes(1);
-  });
-
-  it('merges custom headers with auth header', async () => {
-    mockGetAccessToken.mockResolvedValue('token-123');
-    mockFetch.mockResolvedValueOnce(makeResponse(200));
-
-    await authenticatedFetch('http://test/api', {
-      headers: { Accept: 'application/json' },
-    });
-
-    expect(mockFetch).toHaveBeenCalledWith('http://test/api', {
-      headers: { Accept: 'application/json', Authorization: 'Bearer token-123' },
-    });
-  });
-});