@alumbwe/anvil 1.0.42 → 1.0.49

package/src/utils/__tests__/anvil-model-navigation.test.ts

@@ -1,102 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import {
-  anvilModelNavigationDirectionForKey,
-  nextAnvilModelId,
-} from '../anvil-model-navigation'
-
-describe('nextAnvilModelId', () => {
-  test('moves to the next model when moving forward', () => {
-    const modelIds = ['glm', 'minimax']
-
-    expect(
-      nextAnvilModelId({
-        modelIds,
-        focusedId: 'minimax',
-        direction: 'forward',
-      }),
-    ).toBe('glm')
-  })
-
-  test('moves to the previous model when moving backward', () => {
-    const modelIds = ['glm', 'minimax']
-
-    expect(
-      nextAnvilModelId({
-        modelIds,
-        focusedId: 'minimax',
-        direction: 'backward',
-      }),
-    ).toBe('glm')
-  })
-
-  test('wraps through every model regardless of selectability', () => {
-    const modelIds = ['glm', 'minimax', 'other']
-
-    expect(
-      nextAnvilModelId({
-        modelIds,
-        focusedId: 'minimax',
-        direction: 'forward',
-      }),
-    ).toBe('other')
-  })
-
-  test('returns null when no model exists', () => {
-    expect(
-      nextAnvilModelId({
-        modelIds: [],
-        focusedId: 'glm',
-        direction: 'forward',
-      }),
-    ).toBeNull()
-  })
-})
-
-describe('anvilModelNavigationDirectionForKey', () => {
-  test('maps arrow keys to model navigation directions', () => {
-    expect(anvilModelNavigationDirectionForKey({ name: 'down' })).toBe(
-      'forward',
-    )
-    expect(anvilModelNavigationDirectionForKey({ name: 'right' })).toBe(
-      'forward',
-    )
-    expect(anvilModelNavigationDirectionForKey({ name: 'up' })).toBe(
-      'backward',
-    )
-    expect(anvilModelNavigationDirectionForKey({ name: 'left' })).toBe(
-      'backward',
-    )
-  })
-
-  test('maps tab and shift-tab to model navigation directions', () => {
-    expect(anvilModelNavigationDirectionForKey({ name: 'tab' })).toBe(
-      'forward',
-    )
-    expect(
-      anvilModelNavigationDirectionForKey({ name: 'tab', shift: true }),
-    ).toBe('backward')
-  })
-
-  test('maps terminal tab sequences to model navigation directions', () => {
-    expect(anvilModelNavigationDirectionForKey({ sequence: '\t' })).toBe(
-      'forward',
-    )
-    expect(
-      anvilModelNavigationDirectionForKey({ sequence: '\x1b[9u' }),
-    ).toBe('forward')
-    expect(
-      anvilModelNavigationDirectionForKey({ sequence: '\x1b[Z' }),
-    ).toBe('backward')
-    expect(
-      anvilModelNavigationDirectionForKey({ sequence: '\x1b[9;2u' }),
-    ).toBe('backward')
-    expect(
-      anvilModelNavigationDirectionForKey({ sequence: '\x1b[27;2;9~' }),
-    ).toBe('backward')
-  })
-
-  test('ignores non-navigation keys', () => {
-    expect(anvilModelNavigationDirectionForKey({ name: 'enter' })).toBeNull()
-  })
-})

package/src/utils/__tests__/anvil-premium-reset.test.ts

@@ -1,79 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import {
-  formatAnvilPremiumResetCountdown,
-  getAnvilPremiumResetAt,
-} from '../anvil-premium-reset'
-
-describe('anvil premium reset helpers', () => {
-  test('uses server resetAt when it is in the future', () => {
-    const nowMs = Date.parse('2026-05-11T20:00:00.000Z')
-    const resetAt = getAnvilPremiumResetAt({
-      nowMs,
-      rateLimitsByModel: {
-        'test/model': {
-          model: 'test/model',
-          limit: 5,
-          period: 'pacific_day',
-          resetTimeZone: 'America/Los_Angeles',
-          resetAt: '2026-05-12T07:00:00.000Z',
-          windowHours: 24,
-          recentCount: 2,
-        },
-      },
-    })
-
-    expect(resetAt.toISOString()).toBe('2026-05-12T07:00:00.000Z')
-  })
-
-  test('falls back to next midnight Pacific when resetAt is absent', () => {
-    const resetAt = getAnvilPremiumResetAt({
-      nowMs: Date.parse('2026-05-11T20:00:00.000Z'),
-    })
-
-    expect(resetAt.toISOString()).toBe('2026-05-12T07:00:00.000Z')
-  })
-
-  test('keeps expired server resetAt instead of rolling stale quota forward', () => {
-    const nowMs = Date.parse('2026-05-12T07:05:00.000Z')
-    const resetAt = getAnvilPremiumResetAt({
-      nowMs,
-      rateLimitsByModel: {
-        'test/model': {
-          model: 'test/model',
-          limit: 5,
-          period: 'pacific_day',
-          resetTimeZone: 'America/Los_Angeles',
-          resetAt: '2026-05-12T07:00:00.000Z',
-          windowHours: 24,
-          recentCount: 5,
-        },
-      },
-    })
-
-    expect(resetAt.toISOString()).toBe('2026-05-12T07:00:00.000Z')
-    expect(formatAnvilPremiumResetCountdown(resetAt, nowMs)).toBe('now')
-  })
-
-  test('handles Pacific daylight saving time boundaries', () => {
-    const resetAt = getAnvilPremiumResetAt({
-      nowMs: Date.parse('2026-01-15T20:00:00.000Z'),
-    })
-
-    expect(resetAt.toISOString()).toBe('2026-01-16T08:00:00.000Z')
-  })
-
-  test('formats hours and minutes left', () => {
-    const nowMs = Date.parse('2026-05-11T20:00:00.000Z')
-    const resetAt = new Date('2026-05-12T07:30:00.000Z')
-
-    expect(formatAnvilPremiumResetCountdown(resetAt, nowMs)).toBe('11h 30m')
-  })
-
-  test('formats sub-hour reset countdowns', () => {
-    const nowMs = Date.parse('2026-05-12T06:30:00.000Z')
-    const resetAt = new Date('2026-05-12T07:00:00.000Z')
-
-    expect(formatAnvilPremiumResetCountdown(resetAt, nowMs)).toBe('30m')
-  })
-})

package/src/utils/__tests__/anvil-referral-cache.test.ts

@@ -1,116 +0,0 @@
-import { beforeEach, describe, expect, test } from 'bun:test'
-
-import {
-  clearReferralCache,
-  getCachedReferral,
-  rememberReferral,
-} from '../anvil-referral-cache'
-
-import type { AnvilReferralInfo } from '@anvil/common/types/anvil-session'
-import type { AnvilSessionResponse } from '../../types/anvil-session'
-
-const referral: AnvilReferralInfo = {
-  code: 'ABC123',
-  referrerName: null,
-  qualifiedCount: 2,
-  weeklySessionsRemaining: 1,
-  resetAt: '2026-07-01T00:00:00.000Z',
-  githubLinked: true,
-}
-
-const landingWithReferral = {
-  status: 'none',
-  accessTier: 'full',
-  referral,
-} satisfies AnvilSessionResponse
-
-const activeWithoutReferral = {
-  status: 'active',
-  accessTier: 'full',
-  model: 'minimax/minimax-m3',
-  instanceId: 'i-1',
-  admittedAt: '2026-07-01T00:00:00.000Z',
-  expiresAt: '2026-07-01T01:00:00.000Z',
-  remainingMs: 3_600_000,
-} satisfies AnvilSessionResponse
-
-describe('anvil referral cache', () => {
-  beforeEach(() => {
-    clearReferralCache()
-  })
-
-  test('starts empty', () => {
-    expect(getCachedReferral('full')).toBeUndefined()
-  })
-
-  test('remembers a referral block from a landing response', () => {
-    rememberReferral(landingWithReferral)
-    expect(getCachedReferral('full')).toEqual(referral)
-  })
-
-  test('keeps the last referral across a join → active round-trip', () => {
-    // Simulates: land on picker (referral present) → join a model (server drops
-    // referral from queued/active payloads). The cache must survive so
-    // returning to the picker can still render the GLM banner.
-    rememberReferral(landingWithReferral)
-    rememberReferral(activeWithoutReferral)
-    expect(getCachedReferral('full')).toEqual(referral)
-  })
-
-  test('ignores responses without a referral block', () => {
-    rememberReferral(activeWithoutReferral)
-    expect(getCachedReferral('full')).toBeUndefined()
-  })
-
-  test('an authoritative landing response clears stale referral metadata', () => {
-    rememberReferral(landingWithReferral)
-    rememberReferral({
-      status: 'none',
-      accessTier: 'full',
-    })
-    expect(getCachedReferral('full')).toBeUndefined()
-  })
-
-  test('ignores null sessions', () => {
-    rememberReferral(landingWithReferral)
-    rememberReferral(null)
-    expect(getCachedReferral('full')).toEqual(referral)
-  })
-
-  test('does not reuse referral metadata across access tiers', () => {
-    rememberReferral(landingWithReferral)
-    expect(getCachedReferral('limited')).toBeUndefined()
-  })
-
-  test('retains independent referral metadata for both tiers', () => {
-    const limitedReferral: AnvilReferralInfo = {
-      code: referral.code,
-      referrerName: referral.referrerName,
-      qualifiedCount: 3,
-      githubLinked: referral.githubLinked,
-    }
-    rememberReferral(landingWithReferral)
-    rememberReferral({
-      status: 'none',
-      accessTier: 'limited',
-      referral: limitedReferral,
-    })
-
-    expect(getCachedReferral('full')).toEqual(referral)
-    expect(getCachedReferral('limited')).toEqual(limitedReferral)
-  })
-
-  test('does not cache referral metadata without an access tier', () => {
-    rememberReferral({
-      status: 'none',
-      referral,
-    })
-    expect(getCachedReferral('full')).toBeUndefined()
-  })
-
-  test('clears all account-scoped metadata on session-owner unmount', () => {
-    rememberReferral(landingWithReferral)
-    clearReferralCache()
-    expect(getCachedReferral('full')).toBeUndefined()
-  })
-})

package/src/utils/__tests__/anvil-session-api.test.ts

@@ -1,215 +0,0 @@
-import { afterEach, expect, spyOn, test } from 'bun:test'
-import {
-  ANVIL_GLM_V52_MODEL_ID,
-  resolveAnvilModelForAccessTier,
-} from '@anvil/common/constants/anvil-models'
-
-import {
-  callAnvilSession,
-  classifyAnvilSessionRequestFailure,
-  AnvilSessionRequestError,
-  mergeCompactActiveSession,
-} from '../anvil-session-api'
-
-let fetchSpy: ReturnType<typeof spyOn> | undefined
-
-afterEach(() => {
-  fetchSpy?.mockRestore()
-  fetchSpy = undefined
-})
-
-test('full-tier referral GLM reaches the session POST header unchanged', async () => {
-  fetchSpy = spyOn(globalThis, 'fetch').mockResolvedValue(
-    new Response(JSON.stringify({ status: 'none' }), {
-      headers: { 'content-type': 'application/json' },
-    }),
-  )
-  const resolved = resolveAnvilModelForAccessTier(
-    ANVIL_GLM_V52_MODEL_ID,
-    'full',
-  )
-
-  await callAnvilSession('POST', 'test-token', { model: resolved })
-
-  expect(fetchSpy).toHaveBeenCalledTimes(1)
-  const [, init] = fetchSpy.mock.calls[0]!
-  expect(new Headers(init?.headers).get('x-anvil-model')).toBe(
-    ANVIL_GLM_V52_MODEL_ID,
-  )
-})
-
-test('compact GET sends the compact-session header', async () => {
-  fetchSpy = spyOn(globalThis, 'fetch').mockResolvedValue(
-    Response.json({ status: 'active', model: 'model', instanceId: 'i1' }),
-  )
-
-  await callAnvilSession('GET', 'test-token', {
-    instanceId: 'i1',
-    compact: true,
-  })
-
-  const [, init] = fetchSpy.mock.calls[0]!
-  expect(new Headers(init?.headers).get('x-anvil-compact-session')).toBe('1')
-})
-
-test('compact active state retains the admission quota snapshot', () => {
-  const rateLimit = {
-    model: 'model',
-    limit: 5,
-    period: 'pacific_day' as const,
-    resetTimeZone: 'America/Los_Angeles' as const,
-    resetAt: '2026-08-06T07:00:00.000Z',
-    windowHours: 1,
-    recentCount: 2,
-    entitlementBreakdown: { base: 5, referral: 0, streak: 0 },
-  }
-  const merged = mergeCompactActiveSession(
-    {
-      status: 'active',
-      accessTier: 'full',
-      model: 'model',
-      instanceId: 'i1',
-      admittedAt: '2026-08-05T12:00:00.000Z',
-      expiresAt: '2026-08-05T13:00:00.000Z',
-      remainingMs: 1_000,
-      rateLimit,
-    },
-    {
-      status: 'active',
-      accessTier: 'full',
-      model: 'model',
-      instanceId: 'i1',
-      admittedAt: '2026-08-05T12:00:00.000Z',
-      expiresAt: '2026-08-05T13:00:00.000Z',
-      remainingMs: 500,
-    },
-  )
-
-  expect(merged).toMatchObject({ remainingMs: 500, rateLimit })
-})
-
-test('compact state requests a full refresh instead of carrying quota across models', () => {
-  const merged = mergeCompactActiveSession(
-    {
-      status: 'active',
-      accessTier: 'full',
-      model: 'old-model',
-      instanceId: 'i1',
-      admittedAt: '2026-08-05T12:00:00.000Z',
-      expiresAt: '2026-08-05T13:00:00.000Z',
-      remainingMs: 1_000,
-      rateLimit: {
-        model: 'old-model',
-        limit: 5,
-        period: 'pacific_day',
-        resetTimeZone: 'America/Los_Angeles',
-        resetAt: '2026-08-06T07:00:00.000Z',
-        windowHours: 1,
-        recentCount: 2,
-        entitlementBreakdown: { base: 5, referral: 0, streak: 0 },
-      },
-    },
-    {
-      status: 'active',
-      accessTier: 'full',
-      model: 'new-model',
-      instanceId: 'i1',
-      admittedAt: '2026-08-05T12:00:00.000Z',
-      expiresAt: '2026-08-05T13:00:00.000Z',
-      remainingMs: 500,
-    },
-  )
-
-  expect(merged).toBeNull()
-})
-
-test('does not repeat a takeover POST after an ambiguous timeout', () => {
-  const timeout = new DOMException('The operation timed out', 'TimeoutError')
-
-  expect(classifyAnvilSessionRequestFailure('POST', timeout)).toBe('unknown')
-  expect(classifyAnvilSessionRequestFailure('GET', timeout)).toBe('retry')
-})
-
-test('retries POST responses that cannot represent a committed takeover', async () => {
-  fetchSpy = spyOn(globalThis, 'fetch').mockResolvedValue(
-    Response.json(
-      {
-        error: 'service_overloaded',
-        message: 'Anvil session service is busy. Please retry shortly.',
-      },
-      { status: 503, headers: { 'retry-after': '10' } },
-    ),
-  )
-
-  await expect(callAnvilSession('POST', 'test-token')).rejects.toMatchObject({
-    statusCode: 503,
-    retryAfterMs: 10_000,
-    errorCode: 'service_overloaded',
-  })
-
-  expect(
-    classifyAnvilSessionRequestFailure(
-      'POST',
-      new AnvilSessionRequestError(
-        'busy',
-        503,
-        10_000,
-        'service_overloaded',
-      ),
-    ),
-  ).toBe('retry')
-  expect(
-    classifyAnvilSessionRequestFailure(
-      'POST',
-      new AnvilSessionRequestError('generic proxy 503', 503, 10_000),
-    ),
-  ).toBe('retry')
-  expect(
-    classifyAnvilSessionRequestFailure(
-      'POST',
-      new AnvilSessionRequestError('request timeout', 408, 10_000),
-    ),
-  ).toBe('retry')
-  expect(
-    classifyAnvilSessionRequestFailure(
-      'POST',
-      new AnvilSessionRequestError('edge rate limit', 429, 10_000),
-    ),
-  ).toBe('retry')
-})
-
-test('stops on terminal 4xx responses', () => {
-  expect(
-    classifyAnvilSessionRequestFailure(
-      'POST',
-      new AnvilSessionRequestError('unauthorized', 401),
-    ),
-  ).toBe('stop')
-  expect(
-    classifyAnvilSessionRequestFailure(
-      'GET',
-      new AnvilSessionRequestError('not found', 404),
-    ),
-  ).toBe('stop')
-})
-
-test('marks response loss and server errors after a POST as unknown outcomes', () => {
-  expect(
-    classifyAnvilSessionRequestFailure(
-      'POST',
-      new TypeError('fetch failed'),
-    ),
-  ).toBe('unknown')
-  expect(
-    classifyAnvilSessionRequestFailure(
-      'POST',
-      new AnvilSessionRequestError('internal error', 500),
-    ),
-  ).toBe('unknown')
-  expect(
-    classifyAnvilSessionRequestFailure(
-      'GET',
-      new AnvilSessionRequestError('internal error', 500),
-    ),
-  ).toBe('retry')
-})

package/src/utils/__tests__/anvil-session-display.test.ts

@@ -1,23 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import {
-  formatAnvilSessionCountdown,
-  formatAnvilSessionRemaining,
-} from '../anvil-session-display'
-
-describe('anvil session display formatting', () => {
-  test('formats urgent countdowns', () => {
-    expect(formatAnvilSessionCountdown(61_000)).toBe('1:01')
-    expect(formatAnvilSessionRemaining(61_000)).toBe('1:01 left')
-  })
-
-  test('formats minute and hour remaining labels', () => {
-    expect(formatAnvilSessionRemaining(5 * 60_000)).toBe('5m left')
-    expect(formatAnvilSessionRemaining(60 * 60_000)).toBe('1h left')
-    expect(formatAnvilSessionRemaining(90 * 60_000)).toBe('1h 30m left')
-  })
-
-  test('formats expired sessions as expiring', () => {
-    expect(formatAnvilSessionRemaining(0)).toBe('expiring…')
-  })
-})