@alumbwe/anvil 1.0.19 → 1.0.20

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

@@ -0,0 +1,578 @@
+import { describe, test, expect, mock, beforeEach } from 'bun:test'
+
+import type { FeedbackRequest } from '@anvil/common/schemas/feedback'
+
+import { createAnvilApiClient } from '../anvil-api'
+
+// Type for mocked fetch function
+type MockFetch = (url: string, options?: RequestInit) => Promise<Response>
+
+describe('createAnvilApiClient', () => {
+  let mockFetch: ReturnType<typeof mock<MockFetch>>
+
+  beforeEach(() => {
+    mockFetch = mock<MockFetch>(() =>
+      Promise.resolve({
+        ok: true,
+        status: 200,
+        json: () => Promise.resolve({ id: 'test-id' }),
+      } as Response),
+    )
+  })
+
+  describe('client creation', () => {
+    test('should create client with default base URL', () => {
+      const client = createAnvilApiClient()
+      expect(client.baseUrl).toBeTruthy()
+    })
+
+    test('should create client with custom base URL', () => {
+      const client = createAnvilApiClient({ baseUrl: 'https://custom.api' })
+      expect(client.baseUrl).toBe('https://custom.api')
+    })
+
+    test('should store auth token', () => {
+      const client = createAnvilApiClient({ authToken: 'test-token' })
+      expect(client.authToken).toBe('test-token')
+    })
+  })
+
+  describe('GET requests', () => {
+    test('should make GET request with correct URL', async () => {
+      const client = createAnvilApiClient({
+        baseUrl: 'https://test.api',
+        fetch: mockFetch as unknown as typeof fetch,
+      })
+
+      await client.get('/api/v1/test', { retry: false })
+
+      expect(mockFetch).toHaveBeenCalledTimes(1)
+      const [url] = mockFetch.mock.calls[0] as [string, RequestInit | undefined]
+      expect(url).toBe('https://test.api/api/v1/test')
+    })
+
+    test('should add query parameters', async () => {
+      const client = createAnvilApiClient({
+        baseUrl: 'https://test.api',
+        fetch: mockFetch as unknown as typeof fetch,
+      })
+
+      await client.get('/api/v1/me', {
+        query: { fields: 'id,email' },
+        retry: false,
+      })
+
+      const [url] = mockFetch.mock.calls[0] as [string, RequestInit | undefined]
+      expect(url).toBe('https://test.api/api/v1/me?fields=id%2Cemail')
+    })
+
+    test('should include Authorization header when authToken provided', async () => {
+      const client = createAnvilApiClient({
+        baseUrl: 'https://test.api',
+        authToken: 'my-token',
+        fetch: mockFetch as unknown as typeof fetch,
+      })
+
+      await client.get('/api/v1/test', { retry: false })
+
+      const [, options] = mockFetch.mock.calls[0] as [
+        string,
+        RequestInit | undefined,
+      ]
+      expect(options?.headers).toEqual({
+        Authorization: 'Bearer my-token',
+      })
+    })
+
+    test('should not include Authorization header when includeAuth is false', async () => {
+      const client = createAnvilApiClient({
+        baseUrl: 'https://test.api',
+        authToken: 'my-token',
+        fetch: mockFetch as unknown as typeof fetch,
+      })
+
+      await client.get('/api/v1/test', { includeAuth: false, retry: false })
+
+      const [, options] = mockFetch.mock.calls[0] as [
+        string,
+        RequestInit | undefined,
+      ]
+      expect(options?.headers).toEqual({})
+    })
+  })
+
+  describe('POST requests', () => {
+    test('should make POST request with JSON body', async () => {
+      const client = createAnvilApiClient({
+        baseUrl: 'https://test.api',
+        fetch: mockFetch as unknown as typeof fetch,
+      })
+
+      await client.post('/api/v1/test', { key: 'value' }, { retry: false })
+
+      const [, options] = mockFetch.mock.calls[0] as [
+        string,
+        RequestInit | undefined,
+      ]
+      expect(options?.method).toBe('POST')
+      expect(options?.headers).toEqual({
+        'Content-Type': 'application/json',
+      })
+      expect(options?.body).toBe('{"key":"value"}')
+    })
+
+    test('should include Cookie header when includeCookie is true', async () => {
+      const client = createAnvilApiClient({
+        baseUrl: 'https://test.api',
+        authToken: 'my-token',
+        fetch: mockFetch as unknown as typeof fetch,
+      })
+
+      await client.post(
+        '/api/v1/test',
+        { data: 'test' },
+        { includeCookie: true, includeAuth: false, retry: false },
+      )
+
+      const [, options] = mockFetch.mock.calls[0] as [
+        string,
+        RequestInit | undefined,
+      ]
+      expect(options?.headers).toEqual({
+        'Content-Type': 'application/json',
+        Cookie: 'next-auth.session-token=my-token;',
+      })
+    })
+  })
+
+  describe('PUT requests', () => {
+    test('should make PUT request with JSON body', async () => {
+      const client = createAnvilApiClient({
+        baseUrl: 'https://test.api',
+        fetch: mockFetch as unknown as typeof fetch,
+      })
+
+      await client.put('/api/v1/test', { key: 'value' }, { retry: false })
+
+      const [, options] = mockFetch.mock.calls[0] as [
+        string,
+        RequestInit | undefined,
+      ]
+      expect(options?.method).toBe('PUT')
+      expect(options?.headers).toEqual({
+        'Content-Type': 'application/json',
+      })
+    })
+  })
+
+  describe('PATCH requests', () => {
+    test('should make PATCH request with JSON body', async () => {
+      const client = createAnvilApiClient({
+        baseUrl: 'https://test.api',
+        fetch: mockFetch as unknown as typeof fetch,
+      })
+
+      await client.patch('/api/v1/test', { key: 'value' }, { retry: false })
+
+      const [, options] = mockFetch.mock.calls[0] as [
+        string,
+        RequestInit | undefined,
+      ]
+      expect(options?.method).toBe('PATCH')
+    })
+  })
+
+  describe('DELETE requests', () => {
+    test('should make DELETE request without body', async () => {
+      const client = createAnvilApiClient({
+        baseUrl: 'https://test.api',
+        fetch: mockFetch as unknown as typeof fetch,
+      })
+
+      await client.delete('/api/v1/test/123', { retry: false })
+
+      const [url, options] = mockFetch.mock.calls[0] as [
+        string,
+        RequestInit | undefined,
+      ]
+      expect(url).toBe('https://test.api/api/v1/test/123')
+      expect(options?.method).toBe('DELETE')
+      expect(options?.body).toBeUndefined()
+    })
+  })
+
+  describe('response handling', () => {
+    test('should return ok response with data', async () => {
+      const responseData = { id: 'user-123', email: 'test@example.com' }
+      const mockSuccessFetch = mock<MockFetch>(() =>
+        Promise.resolve({
+          ok: true,
+          status: 200,
+          json: () => Promise.resolve(responseData),
+        } as Response),
+      )
+
+      const client = createAnvilApiClient({
+        baseUrl: 'https://test.api',
+        fetch: mockSuccessFetch as unknown as typeof fetch,
+      })
+
+      const result = await client.get('/api/v1/me', { retry: false })
+
+      expect(result.ok).toBe(true)
+      expect(result.status).toBe(200)
+      if (result.ok) {
+        expect(result.data).toEqual(responseData)
+      }
+    })
+
+    test('should return error response with message', async () => {
+      const mockErrorFetch = mock<MockFetch>(() =>
+        Promise.resolve({
+          ok: false,
+          status: 401,
+          statusText: 'Unauthorized',
+          json: () => Promise.resolve({ error: 'Invalid token' }),
+        } as Response),
+      )
+
+      const client = createAnvilApiClient({
+        baseUrl: 'https://test.api',
+        fetch: mockErrorFetch as unknown as typeof fetch,
+      })
+
+      const result = await client.get('/api/v1/me', { retry: false })
+
+      expect(result.ok).toBe(false)
+      expect(result.status).toBe(401)
+      if (!result.ok) {
+        expect(result.error).toBe('Invalid token')
+      }
+    })
+
+    test('should handle non-JSON error responses', async () => {
+      const mockErrorFetch = mock<MockFetch>(() =>
+        Promise.resolve({
+          ok: false,
+          status: 500,
+          statusText: 'Internal Server Error',
+          json: () => Promise.reject(new Error('Not JSON')),
+          text: () => Promise.resolve('Server error occurred'),
+        } as unknown as Response),
+      )
+
+      const client = createAnvilApiClient({
+        baseUrl: 'https://test.api',
+        fetch: mockErrorFetch as unknown as typeof fetch,
+      })
+
+      const result = await client.get('/api/v1/test', { retry: false })
+
+      expect(result.ok).toBe(false)
+      expect(result.status).toBe(500)
+      if (!result.ok) {
+        expect(result.error).toBe('Server error occurred')
+      }
+    })
+
+    test('should handle 204 No Content responses', async () => {
+      const mockNoContentFetch = mock<MockFetch>(() =>
+        Promise.resolve({
+          ok: true,
+          status: 204,
+          json: () => Promise.reject(new Error('No content')),
+        } as Response),
+      )
+
+      const client = createAnvilApiClient({
+        baseUrl: 'https://test.api',
+        fetch: mockNoContentFetch as unknown as typeof fetch,
+      })
+
+      const result = await client.delete('/api/v1/test/123', { retry: false })
+
+      expect(result.ok).toBe(true)
+      expect(result.status).toBe(204)
+    })
+  })
+
+  describe('retry logic', () => {
+    test('should retry on 500 errors', async () => {
+      let callCount = 0
+      const mockRetryFetch = mock<MockFetch>(() => {
+        callCount++
+        if (callCount < 3) {
+          return Promise.resolve({
+            ok: false,
+            status: 500,
+            statusText: 'Internal Server Error',
+            json: () => Promise.resolve({ error: 'Server error' }),
+          } as Response)
+        }
+        return Promise.resolve({
+          ok: true,
+          status: 200,
+          json: () => Promise.resolve({ success: true }),
+        } as Response)
+      })
+
+      const client = createAnvilApiClient({
+        baseUrl: 'https://test.api',
+        fetch: mockRetryFetch as unknown as typeof fetch,
+        retry: {
+          maxRetries: 3,
+          initialDelayMs: 10, // Fast for testing
+          maxDelayMs: 50,
+        },
+      })
+
+      const result = await client.get('/api/v1/test')
+
+      expect(result.ok).toBe(true)
+      expect(mockRetryFetch).toHaveBeenCalledTimes(3)
+    })
+
+    test('should not retry on 400 errors', async () => {
+      const mockBadRequestFetch = mock<MockFetch>(() =>
+        Promise.resolve({
+          ok: false,
+          status: 400,
+          statusText: 'Bad Request',
+          json: () => Promise.resolve({ error: 'Invalid input' }),
+        } as Response),
+      )
+
+      const client = createAnvilApiClient({
+        baseUrl: 'https://test.api',
+        fetch: mockBadRequestFetch as unknown as typeof fetch,
+        retry: { maxRetries: 3, initialDelayMs: 10 },
+      })
+
+      const result = await client.get('/api/v1/test')
+
+      expect(result.ok).toBe(false)
+      expect(result.status).toBe(400)
+      expect(mockBadRequestFetch).toHaveBeenCalledTimes(1)
+    })
+
+    test('should respect retry: false option', async () => {
+      const mockServerErrorFetch = mock<MockFetch>(() =>
+        Promise.resolve({
+          ok: false,
+          status: 500,
+          statusText: 'Internal Server Error',
+          json: () => Promise.resolve({ error: 'Server error' }),
+        } as Response),
+      )
+
+      const client = createAnvilApiClient({
+        baseUrl: 'https://test.api',
+        fetch: mockServerErrorFetch as unknown as typeof fetch,
+        retry: { maxRetries: 3 },
+      })
+
+      const result = await client.get('/api/v1/test', { retry: false })
+
+      expect(result.ok).toBe(false)
+      expect(mockServerErrorFetch).toHaveBeenCalledTimes(1)
+    })
+
+    test('should retry on network errors', async () => {
+      let callCount = 0
+      const mockNetworkErrorFetch = mock<MockFetch>(() => {
+        callCount++
+        if (callCount < 2) {
+          return Promise.reject(new Error('Network error: fetch failed'))
+        }
+        return Promise.resolve({
+          ok: true,
+          status: 200,
+          json: () => Promise.resolve({ success: true }),
+        } as Response)
+      })
+
+      const client = createAnvilApiClient({
+        baseUrl: 'https://test.api',
+        fetch: mockNetworkErrorFetch as unknown as typeof fetch,
+        retry: { maxRetries: 3, initialDelayMs: 10 },
+      })
+
+      const result = await client.get('/api/v1/test')
+
+      expect(result.ok).toBe(true)
+      expect(mockNetworkErrorFetch).toHaveBeenCalledTimes(2)
+    })
+  })
+
+  describe('timeout', () => {
+    test('should pass abort signal to fetch', async () => {
+      let receivedSignal: AbortSignal | null | undefined
+
+      const mockFetchWithSignal = mock<MockFetch>(
+        async (_url: string, options?: RequestInit) => {
+          receivedSignal = options?.signal
+          return {
+            ok: true,
+            status: 200,
+            json: () => Promise.resolve({ success: true }),
+          } as Response
+        },
+      )
+
+      const client = createAnvilApiClient({
+        baseUrl: 'https://test.api',
+        fetch: mockFetchWithSignal as unknown as typeof fetch,
+        defaultTimeoutMs: 5000,
+      })
+
+      await client.get('/api/v1/test', { retry: false })
+
+      expect(receivedSignal).toBeDefined()
+      expect(receivedSignal instanceof AbortSignal).toBe(true)
+    })
+
+    test('should handle abort error from fetch', async () => {
+      const mockAbortFetch = mock<MockFetch>(() => {
+        const error = new Error('The operation was aborted')
+        error.name = 'AbortError'
+        return Promise.reject(error)
+      })
+
+      const client = createAnvilApiClient({
+        baseUrl: 'https://test.api',
+        fetch: mockAbortFetch as unknown as typeof fetch,
+      })
+
+      // Should retry on abort errors
+      await expect(
+        client.get('/api/v1/test', { retry: false }),
+      ).rejects.toThrow('The operation was aborted')
+    })
+  })
+
+  describe('custom headers', () => {
+    test('should merge custom headers', async () => {
+      const client = createAnvilApiClient({
+        baseUrl: 'https://test.api',
+        authToken: 'my-token',
+        fetch: mockFetch as unknown as typeof fetch,
+      })
+
+      await client.get('/api/v1/test', {
+        headers: { 'X-Custom-Header': 'custom-value' },
+        retry: false,
+      })
+
+      const [, options] = mockFetch.mock.calls[0] as [
+        string,
+        RequestInit | undefined,
+      ]
+      expect(options?.headers).toEqual({
+        'X-Custom-Header': 'custom-value',
+        Authorization: 'Bearer my-token',
+      })
+    })
+  })
+
+  describe('network error formatting', () => {
+    test('formats TLS certificate errors with proxy and trust-store guidance', async () => {
+      const mockTlsFetch = mock<MockFetch>(() => {
+        const error = new Error('self signed certificate in certificate chain')
+        return Promise.reject(error)
+      })
+
+      const client = createAnvilApiClient({
+        baseUrl: 'https://anvil.com',
+        fetch: mockTlsFetch as unknown as typeof fetch,
+      })
+
+      await expect(
+        client.post('/api/auth/cli/code', { fingerprintId: 'test' }),
+      ).rejects.toThrow(
+        'TLS certificate verification failed for https://anvil.com.',
+      )
+    })
+
+    test('formats nested TLS certificate causes from fetch failures without retrying', async () => {
+      const mockTlsFetch = mock<MockFetch>(() => {
+        const cause = new Error('self signed certificate in certificate chain')
+        const error = new Error('fetch failed', { cause })
+        return Promise.reject(error)
+      })
+
+      const client = createAnvilApiClient({
+        baseUrl: 'https://anvil.com',
+        fetch: mockTlsFetch as unknown as typeof fetch,
+        retry: {
+          maxRetries: 3,
+          initialDelayMs: 10,
+        },
+      })
+
+      await expect(
+        client.post('/api/auth/cli/code', { fingerprintId: 'test' }),
+      ).rejects.toThrow(
+        'TLS certificate verification failed for https://anvil.com.',
+      )
+      expect(mockTlsFetch).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('feedback method', () => {
+    const minimalFeedbackPayload: FeedbackRequest = {
+      category: 'other',
+      type: 'general',
+      text: 'test feedback',
+    }
+
+    test('should not retry on 429 (rate limit) responses', async () => {
+      const mockRateLimitFetch = mock<MockFetch>(() =>
+        Promise.resolve({
+          ok: false,
+          status: 429,
+          statusText: 'Too Many Requests',
+          json: () => Promise.resolve({ error: 'Rate limited' }),
+        } as Response),
+      )
+
+      const client = createAnvilApiClient({
+        baseUrl: 'https://test.api',
+        fetch: mockRateLimitFetch as unknown as typeof fetch,
+        retry: { maxRetries: 3, initialDelayMs: 10 },
+      })
+
+      const result = await client.feedback(minimalFeedbackPayload)
+
+      expect(result.ok).toBe(false)
+      expect(result.status).toBe(429)
+      expect(mockRateLimitFetch).toHaveBeenCalledTimes(1)
+    })
+
+    test('should not retry on 500 responses (non-idempotent endpoint)', async () => {
+      const mockServerErrorFetch = mock<MockFetch>(() =>
+        Promise.resolve({
+          ok: false,
+          status: 500,
+          statusText: 'Internal Server Error',
+          json: () => Promise.resolve({ error: 'Server error' }),
+        } as Response),
+      )
+
+      const client = createAnvilApiClient({
+        baseUrl: 'https://test.api',
+        fetch: mockServerErrorFetch as unknown as typeof fetch,
+        retry: {
+          maxRetries: 3,
+          initialDelayMs: 10,
+          maxDelayMs: 50,
+        },
+      })
+
+      const result = await client.feedback(minimalFeedbackPayload)
+
+      expect(result.ok).toBe(false)
+      expect(result.status).toBe(500)
+      expect(mockServerErrorFetch).toHaveBeenCalledTimes(1)
+    })
+  })
+})

package/src/utils/__tests__/anvil-instance-owner.test.ts

@@ -0,0 +1,69 @@
+import fs from 'fs'
+import os from 'os'
+import path from 'path'
+
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+
+import { ensureCliTestEnv } from '../../__tests__/test-utils'
+
+const OWNER_FILE = 'anvil-instance-owner.json'
+
+ensureCliTestEnv()
+
+const { getConfigDir } = await import('../auth')
+const {
+  isAnvilInstanceOwnedByDeadLocalProcess,
+  recordAnvilInstanceOwner,
+} = await import('../anvil-instance-owner')
+
+describe('anvil instance owner', () => {
+  let originalHome: string | undefined
+  let tempHome: string
+
+  const ownerPath = () => path.join(getConfigDir(), OWNER_FILE)
+
+  beforeEach(() => {
+    originalHome = process.env.HOME
+    tempHome = fs.mkdtempSync(path.join(os.tmpdir(), 'anvil-owner-'))
+    process.env.HOME = tempHome
+  })
+
+  afterEach(() => {
+    if (originalHome === undefined) {
+      delete process.env.HOME
+    } else {
+      process.env.HOME = originalHome
+    }
+    fs.rmSync(tempHome, { recursive: true, force: true })
+  })
+
+  test('does not classify the current process as dead', () => {
+    recordAnvilInstanceOwner('inst-current')
+
+    expect(
+      isAnvilInstanceOwnedByDeadLocalProcess('inst-current'),
+    ).toBe(false)
+  })
+
+  test('classifies a matching owner with a dead pid as dead', () => {
+    fs.mkdirSync(getConfigDir(), { recursive: true })
+    fs.writeFileSync(
+      ownerPath(),
+      JSON.stringify({ instanceId: 'inst-dead', pid: 2_147_483_647 }),
+    )
+
+    expect(isAnvilInstanceOwnedByDeadLocalProcess('inst-dead')).toBe(true)
+  })
+
+  test('ignores a dead pid for a different instance id', () => {
+    fs.mkdirSync(getConfigDir(), { recursive: true })
+    fs.writeFileSync(
+      ownerPath(),
+      JSON.stringify({ instanceId: 'inst-other', pid: 2_147_483_647 }),
+    )
+
+    expect(
+      isAnvilInstanceOwnedByDeadLocalProcess('inst-current'),
+    ).toBe(false)
+  })
+})