@alumbwe/anvil 1.0.0

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

@@ -0,0 +1,355 @@
+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

@@ -0,0 +1,144 @@
+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

@@ -0,0 +1,7 @@
+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

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

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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,103 @@
+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
+    })
+  })
+})