@alumbwe/anvil 1.0.0 → 1.0.2

package/src/utils/__tests__/fetch-usage.test.ts

@@ -1,355 +0,0 @@
-import { describe, test, expect, beforeEach, mock } from 'bun:test'
-
-import { fetchAndUpdateUsage } from '../fetch-usage'
-
-import type { AnvilApiClient } from '../anvil-api'
-import type { FetchAndUpdateUsageParams } from '../fetch-usage'
-import type { Logger } from '@anvil/common/types/contracts/logger'
-
-describe('fetchAndUpdateUsage (deprecated)', () => {
-  let setInputModeMock: ReturnType<typeof mock>
-  let getAuthTokenMock: ReturnType<typeof mock>
-  let loggerMock: Logger
-  let apiClientMock: AnvilApiClient
-
-  // Note: fetch-usage now uses apiClient.usage() instead of apiClient.post()
-  const createMockApiClient = (
-    usageMock: ReturnType<typeof mock>,
-  ): AnvilApiClient => ({
-    get: mock(() =>
-      Promise.resolve({ ok: true, status: 200, data: {} }),
-    ) as AnvilApiClient['get'],
-    post: mock(() =>
-      Promise.resolve({ ok: true, status: 200, data: {} }),
-    ) as AnvilApiClient['post'],
-    put: mock(() =>
-      Promise.resolve({ ok: true, status: 200, data: {} }),
-    ) as AnvilApiClient['put'],
-    patch: mock(() =>
-      Promise.resolve({ ok: true, status: 200, data: {} }),
-    ) as AnvilApiClient['patch'],
-    delete: mock(() =>
-      Promise.resolve({ ok: true, status: 200, data: {} }),
-    ) as AnvilApiClient['delete'],
-    request: mock(() =>
-      Promise.resolve({ ok: true, status: 200, data: {} }),
-    ) as AnvilApiClient['request'],
-    me: mock(() =>
-      Promise.resolve({ ok: true, status: 200, data: {} }),
-    ) as AnvilApiClient['me'],
-    usage: usageMock as AnvilApiClient['usage'],
-    loginCode: mock(() =>
-      Promise.resolve({ ok: true, status: 200, data: {} }),
-    ) as AnvilApiClient['loginCode'],
-    loginStatus: mock(() =>
-      Promise.resolve({ ok: true, status: 200, data: {} }),
-    ) as AnvilApiClient['loginStatus'],
-    publish: mock(() =>
-      Promise.resolve({ ok: true, status: 200, data: {} }),
-    ) as AnvilApiClient['publish'],
-    logout: mock(() =>
-      Promise.resolve({ ok: true, status: 200, data: {} }),
-    ) as AnvilApiClient['logout'],
-    feedback: mock(() =>
-      Promise.resolve({ ok: true, status: 200, data: {} }),
-    ) as AnvilApiClient['feedback'],
-    baseUrl: 'https://test.codebuff.com',
-    authToken: 'test-auth-token',
-  })
-
-  const createDefaultParams = (
-    overrides: Partial<FetchAndUpdateUsageParams> = {},
-  ): FetchAndUpdateUsageParams => ({
-    getAuthToken: getAuthTokenMock,
-    getChatStore: () => ({
-      sessionCreditsUsed: 150,
-      setInputMode: setInputModeMock,
-    }),
-    logger: loggerMock,
-    apiClient: apiClientMock,
-    ...overrides,
-  })
-
-  beforeEach(() => {
-    setInputModeMock = mock(() => {})
-    getAuthTokenMock = mock(() => 'test-auth-token')
-    loggerMock = {
-      info: mock(() => {}),
-      error: mock(() => {}),
-      warn: mock(() => {}),
-      debug: mock(() => {}),
-    }
-    const usageMock = mock(async () => ({
-      ok: true,
-      status: 200,
-      data: {
-        type: 'usage-response',
-        usage: 100,
-        remainingBalance: 500,
-        next_quota_reset: '2024-02-01T00:00:00.000Z',
-      },
-    }))
-    apiClientMock = createMockApiClient(usageMock)
-  })
-
-  describe('successful usage refresh', () => {
-    test('should fetch usage data and update store without showing banner', async () => {
-      const result = await fetchAndUpdateUsage(createDefaultParams())
-
-      expect(result).toBe(true)
-      // Note: setUsageData no longer called - data managed by TanStack Query
-      expect(setInputModeMock).not.toHaveBeenCalled()
-    })
-
-    test('should show banner when showBanner parameter is true', async () => {
-      const result = await fetchAndUpdateUsage(
-        createDefaultParams({ showBanner: true }),
-      )
-
-      expect(result).toBe(true)
-      // Note: setUsageData no longer called - data managed by TanStack Query
-      expect(setInputModeMock).toHaveBeenCalledTimes(1)
-      expect(setInputModeMock.mock.calls[0][0]).toBe('usage')
-    })
-
-    test('should handle null remainingBalance correctly', async () => {
-      const usageMock = mock(async () => ({
-        ok: true,
-        status: 200,
-        data: {
-          type: 'usage-response',
-          usage: 100,
-          remainingBalance: null,
-          next_quota_reset: null,
-        },
-      }))
-      const client = createMockApiClient(usageMock)
-
-      const result = await fetchAndUpdateUsage(
-        createDefaultParams({ apiClient: client }),
-      )
-
-      expect(result).toBe(true)
-      // Note: setUsageData no longer called - data managed by TanStack Query
-    })
-
-    test('should send correct request to API', async () => {
-      const usageMock = mock(async () => ({
-        ok: true,
-        status: 200,
-        data: {
-          type: 'usage-response',
-          usage: 100,
-          remainingBalance: 500,
-          next_quota_reset: '2024-02-01T00:00:00.000Z',
-        },
-      }))
-      const client = createMockApiClient(usageMock)
-
-      await fetchAndUpdateUsage(createDefaultParams({ apiClient: client }))
-
-      expect(usageMock).toHaveBeenCalledTimes(1)
-    })
-  })
-
-  describe('authentication handling', () => {
-    test('should return false when user is not authenticated', async () => {
-      getAuthTokenMock.mockReturnValue(undefined)
-
-      const result = await fetchAndUpdateUsage(createDefaultParams())
-
-      expect(result).toBe(false)
-      expect(setInputModeMock).not.toHaveBeenCalled()
-      expect(loggerMock.debug).toHaveBeenCalled()
-    })
-
-    test('should not make API call when auth token is missing', async () => {
-      getAuthTokenMock.mockReturnValue(null)
-      const usageMock = mock(async () => ({ ok: true, status: 200 }))
-      const client = createMockApiClient(usageMock)
-
-      await fetchAndUpdateUsage(createDefaultParams({ apiClient: client }))
-
-      expect(usageMock).not.toHaveBeenCalled()
-    })
-  })
-
-  describe('error handling', () => {
-    test('should return false on HTTP error responses', async () => {
-      const usageMock = mock(async () => ({
-        ok: false,
-        status: 500,
-        error: 'Internal Server Error',
-      }))
-      const client = createMockApiClient(usageMock)
-
-      const result = await fetchAndUpdateUsage(
-        createDefaultParams({ apiClient: client }),
-      )
-
-      expect(result).toBe(false)
-      expect(loggerMock.error).toHaveBeenCalled()
-    })
-
-    test('should return false on 401 Unauthorized', async () => {
-      const usageMock = mock(async () => ({
-        ok: false,
-        status: 401,
-        error: 'Unauthorized',
-      }))
-      const client = createMockApiClient(usageMock)
-
-      const result = await fetchAndUpdateUsage(
-        createDefaultParams({ apiClient: client }),
-      )
-
-      expect(result).toBe(false)
-    })
-
-    test('should return false on network errors', async () => {
-      const usageMock = mock(async () => {
-        throw new Error('Network connection failed')
-      })
-      const client = createMockApiClient(usageMock)
-
-      const result = await fetchAndUpdateUsage(
-        createDefaultParams({ apiClient: client }),
-      )
-
-      expect(result).toBe(false)
-      expect(loggerMock.error).toHaveBeenCalled()
-    })
-
-    test('should return false on malformed JSON response', async () => {
-      const usageMock = mock(async () => ({
-        ok: false,
-        status: 200,
-        error: 'Invalid JSON',
-      }))
-      const client = createMockApiClient(usageMock)
-
-      const result = await fetchAndUpdateUsage(
-        createDefaultParams({ apiClient: client }),
-      )
-
-      expect(result).toBe(false)
-    })
-
-    test('should handle fetch timeout gracefully', async () => {
-      const usageMock = mock(async () => {
-        const error = new Error('Request timeout')
-        error.name = 'TimeoutError'
-        throw error
-      })
-      const client = createMockApiClient(usageMock)
-
-      const result = await fetchAndUpdateUsage(
-        createDefaultParams({ apiClient: client }),
-      )
-
-      expect(result).toBe(false)
-      expect(loggerMock.error).toHaveBeenCalled()
-    })
-  })
-
-  describe('session credits handling', () => {
-    test('should use current session credits in usage data', async () => {
-      const result = await fetchAndUpdateUsage(
-        createDefaultParams({
-          getChatStore: () => ({
-            sessionCreditsUsed: 250,
-            setInputMode: setInputModeMock,
-          }),
-        }),
-      )
-
-      expect(result).toBe(true)
-      // Note: setUsageData no longer called - data managed by TanStack Query
-    })
-
-    test('should handle zero session credits', async () => {
-      const result = await fetchAndUpdateUsage(
-        createDefaultParams({
-          getChatStore: () => ({
-            sessionCreditsUsed: 0,
-            setInputMode: setInputModeMock,
-          }),
-        }),
-      )
-
-      expect(result).toBe(true)
-      // Note: setUsageData no longer called - data managed by TanStack Query
-    })
-  })
-
-  describe('edge cases', () => {
-    test('should handle empty response body gracefully', async () => {
-      const usageMock = mock(async () => ({
-        ok: true,
-        status: 200,
-        data: null,
-      }))
-      const client = createMockApiClient(usageMock)
-
-      // With the new API client, empty/null data is treated as success
-      // since ok: true indicates the request succeeded
-      const result = await fetchAndUpdateUsage(
-        createDefaultParams({ apiClient: client }),
-      )
-
-      expect(result).toBe(true)
-    })
-
-    test('should handle missing balanceBreakdown field', async () => {
-      const usageMock = mock(async () => ({
-        ok: true,
-        status: 200,
-        data: {
-          type: 'usage-response',
-          usage: 50,
-          remainingBalance: 450,
-          next_quota_reset: '2024-02-01T00:00:00.000Z',
-        },
-      }))
-      const client = createMockApiClient(usageMock)
-
-      const result = await fetchAndUpdateUsage(
-        createDefaultParams({ apiClient: client }),
-      )
-
-      expect(result).toBe(true)
-      // Note: setUsageData no longer called - data managed by TanStack Query
-    })
-
-    test('should handle concurrent calls correctly', async () => {
-      let callCount = 0
-      const usageMock = mock(async () => {
-        callCount++
-        await new Promise((resolve) => setTimeout(resolve, 10))
-        return {
-          ok: true,
-          status: 200,
-          data: {
-            type: 'usage-response',
-            usage: 100,
-            remainingBalance: 900 - callCount * 10,
-            next_quota_reset: null,
-          },
-        }
-      })
-      const client = createMockApiClient(usageMock)
-
-      const results = await Promise.all([
-        fetchAndUpdateUsage(createDefaultParams({ apiClient: client })),
-        fetchAndUpdateUsage(createDefaultParams({ apiClient: client })),
-        fetchAndUpdateUsage(
-          createDefaultParams({ apiClient: client, showBanner: true }),
-        ),
-      ])
-
-      expect(results).toEqual([true, true, true])
-      // Note: setUsageData no longer called - data managed by TanStack Query
-      expect(setInputModeMock).toHaveBeenCalledTimes(1)
-    })
-  })
-})

package/src/utils/__tests__/fingerprint.test.ts

@@ -1,144 +0,0 @@
-import { describe, test, expect } from 'bun:test'
-
-import { getFingerprintType, generateFingerprintIdSync } from '../fingerprint'
-
-describe('fingerprint utilities', () => {
-  describe('getFingerprintType', () => {
-    describe('enhanced fingerprints', () => {
-      test('should detect enhanced- prefix as enhanced_cli', () => {
-        expect(getFingerprintType('enhanced-abc123')).toBe('enhanced_cli')
-      })
-
-      test('should detect enhanced fingerprint with full hash', () => {
-        const fullHash = 'enhanced-Ks7mN2pQxR3vW5yZ8aB4cD6eF9gH1iJ2kL4mN5oP7qR8sT0uV1wX3yZ'
-        expect(getFingerprintType(fullHash)).toBe('enhanced_cli')
-      })
-
-      test('should detect enhanced- prefix with empty suffix', () => {
-        expect(getFingerprintType('enhanced-')).toBe('enhanced_cli')
-      })
-    })
-
-    describe('legacy fingerprints', () => {
-      test('should detect anvil-cli- prefix as legacy', () => {
-        expect(getFingerprintType('anvil-cli-abc12345')).toBe('legacy')
-      })
-
-      test('should detect legacy- prefix as legacy', () => {
-        expect(getFingerprintType('legacy-abc123-xyz789')).toBe('legacy')
-      })
-
-      test('should detect anvil-cli- prefix with any suffix', () => {
-        expect(getFingerprintType('anvil-cli-')).toBe('legacy')
-        expect(getFingerprintType('anvil-cli-randomsuffix')).toBe('legacy')
-        expect(getFingerprintType('anvil-cli-12345678')).toBe('legacy')
-      })
-
-      test('should detect legacy- prefix with any suffix', () => {
-        expect(getFingerprintType('legacy-')).toBe('legacy')
-        expect(getFingerprintType('legacy-hash-suffix')).toBe('legacy')
-      })
-    })
-
-    describe('unknown fingerprints', () => {
-      test('should return unknown for empty string', () => {
-        expect(getFingerprintType('')).toBe('unknown')
-      })
-
-      test('should return unknown for unrecognized prefix', () => {
-        expect(getFingerprintType('unknown-prefix-123')).toBe('unknown')
-      })
-
-      test('should return unknown for partial matches', () => {
-        // Should not match if prefix is incomplete
-        expect(getFingerprintType('enhance-abc123')).toBe('unknown')
-        expect(getFingerprintType('anvil-abc123')).toBe('unknown')
-        expect(getFingerprintType('lega-abc123')).toBe('unknown')
-      })
-
-      test('should return unknown for SDK fingerprints', () => {
-        expect(getFingerprintType('anvil-sdk-abc123')).toBe('unknown')
-      })
-
-      test('should return unknown for random strings', () => {
-        expect(getFingerprintType('random-string')).toBe('unknown')
-        expect(getFingerprintType('abc123')).toBe('unknown')
-        expect(getFingerprintType('fingerprint')).toBe('unknown')
-      })
-
-      test('should be case-sensitive', () => {
-        expect(getFingerprintType('Enhanced-abc123')).toBe('unknown')
-        expect(getFingerprintType('ENHANCED-abc123')).toBe('unknown')
-        expect(getFingerprintType('Anvil-cli-abc123')).toBe('unknown')
-        expect(getFingerprintType('LEGACY-abc123')).toBe('unknown')
-      })
-    })
-  })
-
-  describe('generateFingerprintIdSync', () => {
-    describe('format validation', () => {
-      test('should return string starting with anvil-cli-', () => {
-        const fingerprint = generateFingerprintIdSync()
-        expect(fingerprint.startsWith('anvil-cli-')).toBe(true)
-      })
-
-      test('should return fingerprint of expected length', () => {
-        const fingerprint = generateFingerprintIdSync()
-        // Format: anvil-cli- (13 chars) + 8 random chars = 21 chars
-        expect(fingerprint.length).toBe(21)
-      })
-
-      test('should contain only valid base64url characters in suffix', () => {
-        const fingerprint = generateFingerprintIdSync()
-        const suffix = fingerprint.replace('anvil-cli-', '')
-        // base64url alphabet: A-Z, a-z, 0-9, -, _
-        const base64urlPattern = /^[A-Za-z0-9_-]+$/
-        expect(base64urlPattern.test(suffix)).toBe(true)
-      })
-
-      test('should have exactly 8 characters in the random suffix', () => {
-        const fingerprint = generateFingerprintIdSync()
-        const suffix = fingerprint.replace('anvil-cli-', '')
-        expect(suffix.length).toBe(8)
-      })
-    })
-
-    describe('uniqueness', () => {
-      test('should generate unique fingerprints across multiple calls', () => {
-        const fingerprints = new Set<string>()
-        const iterations = 100
-
-        for (let i = 0; i < iterations; i++) {
-          fingerprints.add(generateFingerprintIdSync())
-        }
-
-        // All fingerprints should be unique
-        expect(fingerprints.size).toBe(iterations)
-      })
-
-      test('should generate different fingerprints on consecutive calls', () => {
-        const first = generateFingerprintIdSync()
-        const second = generateFingerprintIdSync()
-        const third = generateFingerprintIdSync()
-
-        expect(first).not.toBe(second)
-        expect(second).not.toBe(third)
-        expect(first).not.toBe(third)
-      })
-    })
-
-    describe('type detection integration', () => {
-      test('should be detected as legacy by getFingerprintType', () => {
-        const fingerprint = generateFingerprintIdSync()
-        expect(getFingerprintType(fingerprint)).toBe('legacy')
-      })
-
-      test('multiple generated fingerprints should all be detected as legacy', () => {
-        for (let i = 0; i < 10; i++) {
-          const fingerprint = generateFingerprintIdSync()
-          expect(getFingerprintType(fingerprint)).toBe('legacy')
-        }
-      })
-    })
-  })
-})

package/src/utils/__tests__/fixtures/terminal-command-broker-child.ts

@@ -1,7 +0,0 @@
-import { writeFileSync } from 'fs'
-
-const [pidPath] = process.argv.slice(2)
-if (!pidPath) process.exit(2)
-
-writeFileSync(pidPath, String(process.pid))
-setInterval(() => {}, 1_000)

package/src/utils/__tests__/fixtures/terminal-command-broker-entry.ts

@@ -1,3 +0,0 @@
-import { serveTerminalCommandBroker } from '../../terminal-command-broker'
-
-await serveTerminalCommandBroker()

package/src/utils/__tests__/fixtures/terminal-command-broker-owner.ts

@@ -1,33 +0,0 @@
-import { writeFileSync } from 'fs'
-
-import {
-  getActiveTerminalCommandProcesses,
-  runTerminalCommand,
-} from '@anvil/sdk'
-
-import { createTerminalCommandBroker } from '../../terminal-command-broker'
-
-const [brokerEntry, childEntry, brokerPidPath, commandPidPath] =
-  process.argv.slice(2)
-if (!brokerEntry || !childEntry || !brokerPidPath || !commandPidPath) {
-  process.exit(2)
-}
-const shellExecutable = process.execPath.replaceAll('\\', '/')
-const shellChildEntry = childEntry.replaceAll('\\', '/')
-const shellCommandPidPath = commandPidPath.replaceAll('\\', '/')
-
-const run = runTerminalCommand({
-  command: `exec ${JSON.stringify(shellExecutable)} ${JSON.stringify(shellChildEntry)} ${JSON.stringify(shellCommandPidPath)}`,
-  process_type: 'SYNC',
-  cwd: process.cwd(),
-  timeout_seconds: 30,
-  terminalCommandBroker: createTerminalCommandBroker({
-    invocation: () => ({ executable: process.execPath, args: [brokerEntry] }),
-  }),
-})
-
-const brokerPid = getActiveTerminalCommandProcesses().at(-1)?.pid
-if (!brokerPid) process.exit(3)
-writeFileSync(brokerPidPath, String(brokerPid))
-
-await run

package/src/utils/__tests__/format-elapsed-time.test.ts

@@ -1,103 +0,0 @@
-import { describe, test, expect } from 'bun:test'
-
-import { formatElapsedTime } from '../format-elapsed-time'
-
-describe('formatElapsedTime', () => {
-  describe('seconds format (< 60s)', () => {
-    test('formats 0 seconds', () => {
-      expect(formatElapsedTime(0)).toBe('0s')
-    })
-
-    test('formats single digit seconds', () => {
-      expect(formatElapsedTime(5)).toBe('5s')
-      expect(formatElapsedTime(9)).toBe('9s')
-    })
-
-    test('formats double digit seconds', () => {
-      expect(formatElapsedTime(30)).toBe('30s')
-      expect(formatElapsedTime(45)).toBe('45s')
-      expect(formatElapsedTime(59)).toBe('59s')
-    })
-  })
-
-  describe('minutes format (60s - 3599s)', () => {
-    test('formats exactly 1 minute', () => {
-      expect(formatElapsedTime(60)).toBe('1m')
-    })
-
-    test('formats minutes with remaining seconds (floors down)', () => {
-      expect(formatElapsedTime(90)).toBe('1m 30s')
-      expect(formatElapsedTime(119)).toBe('1m 59s')
-      expect(formatElapsedTime(125)).toBe('2m 5s')
-    })
-
-    test('formats double digit minutes', () => {
-      expect(formatElapsedTime(600)).toBe('10m')
-      expect(formatElapsedTime(1800)).toBe('30m')
-      expect(formatElapsedTime(3540)).toBe('59m')
-    })
-
-    test('formats just under 1 hour', () => {
-      expect(formatElapsedTime(3599)).toBe('59m 59s')
-    })
-  })
-
-  describe('hours format (>= 3600s)', () => {
-    test('formats exactly 1 hour', () => {
-      expect(formatElapsedTime(3600)).toBe('1h')
-    })
-
-    test('formats hours with remaining time (floors down)', () => {
-      expect(formatElapsedTime(3661)).toBe('1h 1m')
-      expect(formatElapsedTime(5400)).toBe('1h 30m')
-      expect(formatElapsedTime(7199)).toBe('1h 59m')
-      expect(formatElapsedTime(7200)).toBe('2h')
-    })
-
-    test('formats multiple hours', () => {
-      expect(formatElapsedTime(10800)).toBe('3h')
-      expect(formatElapsedTime(36000)).toBe('10h')
-      expect(formatElapsedTime(86400)).toBe('24h')
-    })
-  })
-
-  describe('edge cases', () => {
-    test('handles very large numbers', () => {
-      expect(formatElapsedTime(999999)).toBe('277h 46m')
-    })
-
-    test('handles negative numbers gracefully (should not occur in practice)', () => {
-      // Negative numbers shouldn't happen, but verify behavior
-      const result = formatElapsedTime(-10)
-      // Will return "-10s" - negative formatting is technically wrong but harmless
-      expect(result).toBe('-10s')
-    })
-
-    test('handles boundary between seconds and minutes', () => {
-      expect(formatElapsedTime(59)).toBe('59s')
-      expect(formatElapsedTime(60)).toBe('1m')
-      expect(formatElapsedTime(61)).toBe('1m 1s')
-    })
-
-    test('handles boundary between minutes and hours', () => {
-      expect(formatElapsedTime(3599)).toBe('59m 59s')
-      expect(formatElapsedTime(3600)).toBe('1h')
-      expect(formatElapsedTime(3601)).toBe('1h') // 1 second rounds down to 0 minutes, shows as 1h
-    })
-  })
-
-  describe('real-world scenarios', () => {
-    test('formats typical LLM response times', () => {
-      expect(formatElapsedTime(3)).toBe('3s') // Quick response
-      expect(formatElapsedTime(15)).toBe('15s') // Average response
-      expect(formatElapsedTime(45)).toBe('45s') // Longer response
-      expect(formatElapsedTime(120)).toBe('2m') // Very long response
-    })
-
-    test('formats extended task durations', () => {
-      expect(formatElapsedTime(180)).toBe('3m') // 3 minute task
-      expect(formatElapsedTime(900)).toBe('15m') // 15 minute task
-      expect(formatElapsedTime(3600)).toBe('1h') // 1 hour task
-    })
-  })
-})