@alumbwe/anvil 1.0.0

package/src/__tests__/e2e/first-time-login.test.ts

@@ -0,0 +1,173 @@
+import { describe, test, expect, mock } from 'bun:test'
+
+import { createMockLogger } from '@anvil/common/testing/mock-types'
+import {
+  generateLoginUrl,
+  pollLoginStatus,
+  type LoginUrlResponse,
+} from '../../login/login-flow'
+import { createMockApiClient } from '../helpers/mock-api-client'
+
+import type { ApiResponse } from '../../utils/anvil-api'
+
+describe('First-Time Login Flow (helpers)', () => {
+  test('generateLoginUrl posts fingerprint id and returns payload', async () => {
+    const logger = createMockLogger()
+    const responsePayload: LoginUrlResponse = {
+      loginUrl: 'https://cli.test/login?code=abc123',
+      fingerprintHash: 'hash-123',
+      expiresAt: '2025-12-31T23:59:59Z',
+    }
+
+    const loginCodeMock = mock(async (req: { fingerprintId: string }) => {
+      expect(req.fingerprintId).toBe('finger-001')
+      return {
+        ok: true,
+        status: 200,
+        data: responsePayload,
+      } as ApiResponse<LoginUrlResponse>
+    })
+
+    const apiClient = createMockApiClient({ loginCode: loginCodeMock })
+
+    const result = await generateLoginUrl(
+      { logger, apiClient },
+      { baseUrl: 'https://cli.test', fingerprintId: 'finger-001' },
+    )
+
+    expect(result).toEqual(responsePayload)
+    expect(loginCodeMock.mock.calls.length).toBe(1)
+  })
+
+  test('pollLoginStatus resolves with user after handling transient 401 responses', async () => {
+    const logger = createMockLogger()
+    const apiResponses: Array<ApiResponse<{ user?: unknown }>> = [
+      { ok: false, status: 401 },
+      { ok: false, status: 401 },
+      {
+        ok: true,
+        status: 200,
+        data: {
+          user: {
+            id: 'new-user-123',
+            name: 'New User',
+            email: 'new@anvil.dev',
+            authToken: 'token-123',
+          },
+        },
+      },
+    ]
+    let callCount = 0
+
+    const loginStatusMock = mock(
+      async (req: {
+        fingerprintId: string
+        fingerprintHash: string
+        expiresAt: string
+      }) => {
+        expect(req.fingerprintId).toBe('finger-abc')
+        expect(req.fingerprintHash).toBe('hash-xyz')
+        expect(req.expiresAt).toBe('2030-01-02T03:04:05Z')
+
+        const response =
+          apiResponses[callCount] ?? apiResponses[apiResponses.length - 1]
+        callCount += 1
+        return response
+      },
+    )
+
+    const apiClient = createMockApiClient({ loginStatus: loginStatusMock })
+
+    const result = await pollLoginStatus(
+      {
+        sleep: async () => {},
+        logger,
+        apiClient,
+      },
+      {
+        baseUrl: 'https://cli.test',
+        fingerprintId: 'finger-abc',
+        fingerprintHash: 'hash-xyz',
+        expiresAt: '2030-01-02T03:04:05Z',
+      },
+    )
+
+    expect(result.status).toBe('success')
+    if (result.status !== 'success') {
+      throw new Error(`Expected polling success but received ${result.status}`)
+    }
+    expect(result.attempts).toBe(3)
+    const user = result.user as { id?: unknown }
+    expect(user?.id).toBe('new-user-123')
+    expect(loginStatusMock.mock.calls.length).toBe(3)
+  })
+
+  test('pollLoginStatus times out when user never appears', async () => {
+    const logger = createMockLogger()
+    let nowTime = 0
+    const intervalMs = 5000
+    const timeoutMs = 20000
+
+    const loginStatusMock = mock(async () => {
+      return { ok: false, status: 401 } as ApiResponse<{ user?: unknown }>
+    })
+
+    const apiClient = createMockApiClient({ loginStatus: loginStatusMock })
+
+    const sleep = async () => {
+      nowTime += intervalMs
+    }
+
+    const result = await pollLoginStatus(
+      {
+        sleep,
+        logger,
+        now: () => nowTime,
+        apiClient,
+      },
+      {
+        baseUrl: 'https://cli.test',
+        fingerprintId: 'finger-timeout',
+        fingerprintHash: 'hash-timeout',
+        expiresAt: '2030-01-02T03:04:05Z',
+        intervalMs,
+        timeoutMs,
+      },
+    )
+
+    expect(result.status).toBe('timeout')
+    expect(loginStatusMock.mock.calls.length).toBeGreaterThan(0)
+  })
+
+  test('pollLoginStatus stops when caller aborts', async () => {
+    const logger = createMockLogger()
+    const loginStatusMock = mock(async () => {
+      return { ok: false, status: 401 } as ApiResponse<{ user?: unknown }>
+    })
+
+    const apiClient = createMockApiClient({ loginStatus: loginStatusMock })
+
+    let shouldContinue = true
+
+    const resultPromise = pollLoginStatus(
+      {
+        sleep: async () => {
+          shouldContinue = false
+        },
+        logger,
+        apiClient,
+      },
+      {
+        baseUrl: 'https://cli.test',
+        fingerprintId: 'finger-abort',
+        fingerprintHash: 'hash-abort',
+        expiresAt: '2030-01-02T03:04:05Z',
+        shouldContinue: () => shouldContinue,
+      },
+    )
+
+    const result = await resultPromise
+    expect(result.status).toBe('aborted')
+    expect(loginStatusMock.mock.calls.length).toBeGreaterThan(0)
+  })
+})

package/src/__tests__/e2e/logout-relogin-flow.test.ts

@@ -0,0 +1,110 @@
+import fs from 'fs'
+import os from 'os'
+import path from 'path'
+
+import {
+  describe,
+  test,
+  expect,
+  beforeEach,
+  afterEach,
+  mock,
+  spyOn,
+} from 'bun:test'
+
+import { setProjectRoot } from '../../project-files'
+import {
+  saveUserCredentials,
+  getUserCredentials,
+  logoutUser,
+} from '../../utils/auth'
+import * as AuthModule from '../../utils/auth'
+import * as AnvilApiModule from '../../utils/anvil-api'
+
+type User = AuthModule.User
+
+const ORIGINAL_USER: User = {
+  id: 'user-001',
+  name: 'CLI Tester',
+  email: 'tester@anvil.dev',
+  authToken: 'token-original',
+  fingerprintId: 'fingerprint-original',
+  fingerprintHash: 'fingerprint-hash-original',
+}
+
+const RELOGIN_USER: User = {
+  ...ORIGINAL_USER,
+  authToken: 'token-after-relogin',
+  fingerprintId: 'fingerprint-new',
+  fingerprintHash: 'fingerprint-hash-new',
+}
+
+describe('Logout and Re-login helpers', () => {
+  let tempConfigDir: string
+
+  beforeEach(() => {
+    tempConfigDir = fs.mkdtempSync(path.join(os.tmpdir(), 'manicode-logout-'))
+    // Set project root to avoid "Project root not set" error in logger
+    setProjectRoot(tempConfigDir)
+  })
+
+  afterEach(() => {
+    if (fs.existsSync(tempConfigDir)) {
+      fs.rmSync(tempConfigDir, { recursive: true, force: true })
+    }
+    mock.restore()
+  })
+
+  const mockConfigPaths = () => {
+    spyOn(AuthModule, 'getConfigDir').mockReturnValue(tempConfigDir)
+    spyOn(AuthModule, 'getCredentialsPath').mockReturnValue(
+      path.join(tempConfigDir, 'credentials.json'),
+    )
+  }
+
+  const mockLogoutApi = () => {
+    spyOn(AnvilApiModule, 'getApiClient').mockReturnValue({
+      logout: async () => ({ ok: true, status: 200 }),
+    } as ReturnType<typeof AnvilApiModule.getApiClient>)
+  }
+
+  test('logoutUser removes credentials file and returns true', async () => {
+    mockConfigPaths()
+    mockLogoutApi()
+    saveUserCredentials(ORIGINAL_USER)
+
+    const credentialsPath = path.join(tempConfigDir, 'credentials.json')
+    expect(fs.existsSync(credentialsPath)).toBe(true)
+
+    const result = await logoutUser()
+    expect(result).toBe(true)
+    expect(fs.existsSync(credentialsPath)).toBe(false)
+  })
+
+  test('re-login can persist new credentials after logout', async () => {
+    mockConfigPaths()
+    mockLogoutApi()
+
+    saveUserCredentials(ORIGINAL_USER)
+    const firstLoaded = getUserCredentials()
+    expect(firstLoaded?.authToken).toBe('token-original')
+
+    await logoutUser()
+    expect(getUserCredentials()).toBeNull()
+
+    saveUserCredentials(RELOGIN_USER)
+    const reloaded = getUserCredentials()
+    expect(reloaded?.authToken).toBe('token-after-relogin')
+    expect(reloaded?.fingerprintId).toBe('fingerprint-new')
+  })
+
+  test('logoutUser is idempotent when credentials are already missing', async () => {
+    mockConfigPaths()
+
+    const resultFirst = await logoutUser()
+    expect(resultFirst).toBe(true)
+
+    const resultSecond = await logoutUser()
+    expect(resultSecond).toBe(true)
+  })
+})

package/src/__tests__/e2e/returning-user-auth.test.ts

@@ -0,0 +1,113 @@
+import fs from 'fs'
+import os from 'os'
+import path from 'path'
+
+import { API_KEY_ENV_VAR } from '@anvil/common/old-constants'
+import {
+  describe,
+  test,
+  expect,
+  beforeEach,
+  afterEach,
+  mock,
+  spyOn,
+} from 'bun:test'
+
+import { validateApiKey } from '../../hooks/use-auth-query'
+import * as AuthModule from '../../utils/auth'
+import { getAuthTokenDetails, saveUserCredentials } from '../../utils/auth'
+
+import type { GetUserInfoFromApiKeyFn } from '@anvil/common/types/contracts/database'
+import type { Logger } from '@anvil/common/types/contracts/logger'
+
+type User = AuthModule.User
+
+const RETURNING_USER: User = {
+  id: 'returning-user-456',
+  name: 'Returning User',
+  email: 'returning@example.com',
+  authToken: 'valid-session-token-xyz',
+  fingerprintId: 'returning-fingerprint',
+  fingerprintHash: 'returning-hash',
+}
+
+const createLogger = (): Logger & Record<string, ReturnType<typeof mock>> => ({
+  info: mock(() => {}),
+  error: mock(() => {}),
+  warn: mock(() => {}),
+  debug: mock(() => {}),
+})
+
+describe('Returning User Authentication helpers', () => {
+  const originalEnv: Record<string, string | undefined> = {}
+  let tempConfigDir: string
+
+  beforeEach(() => {
+    tempConfigDir = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'manicode-returning-'),
+    )
+    originalEnv[API_KEY_ENV_VAR] = process.env[API_KEY_ENV_VAR]
+  })
+
+  afterEach(() => {
+    if (fs.existsSync(tempConfigDir)) {
+      fs.rmSync(tempConfigDir, { recursive: true, force: true })
+    }
+    process.env[API_KEY_ENV_VAR] = originalEnv[API_KEY_ENV_VAR]
+    mock.restore()
+  })
+
+  test('should load auth token from credentials file for returning user', () => {
+    spyOn(AuthModule, 'getConfigDir').mockReturnValue(tempConfigDir)
+    spyOn(AuthModule, 'getCredentialsPath').mockReturnValue(
+      path.join(tempConfigDir, 'credentials.json'),
+    )
+
+    saveUserCredentials(RETURNING_USER)
+
+    const details = getAuthTokenDetails()
+    expect(details.source).toBe('credentials')
+    expect(details.token).toBe(RETURNING_USER.authToken)
+  })
+
+  test('should fall back to ANVIL_API_KEY when credentials are missing', () => {
+    spyOn(AuthModule, 'getConfigDir').mockReturnValue(tempConfigDir)
+    spyOn(AuthModule, 'getCredentialsPath').mockReturnValue(
+      path.join(tempConfigDir, 'credentials.json'),
+    )
+
+    process.env[API_KEY_ENV_VAR] = 'env-token-123'
+
+    const details = getAuthTokenDetails()
+    expect(details.source).toBe('environment')
+    expect(details.token).toBe('env-token-123')
+  })
+
+  test('should validate stored credentials without blocking the UI thread', async () => {
+    spyOn(AuthModule, 'getConfigDir').mockReturnValue(tempConfigDir)
+    spyOn(AuthModule, 'getCredentialsPath').mockReturnValue(
+      path.join(tempConfigDir, 'credentials.json'),
+    )
+
+    saveUserCredentials(RETURNING_USER)
+
+    const logger = createLogger()
+    const mockGetUserInfoFromApiKey: GetUserInfoFromApiKeyFn = mock(
+      async () => ({
+        id: RETURNING_USER.id,
+        email: RETURNING_USER.email,
+      }),
+    ) as GetUserInfoFromApiKeyFn
+
+    const result = await validateApiKey({
+      apiKey: RETURNING_USER.authToken,
+      getUserInfoFromApiKey: mockGetUserInfoFromApiKey,
+      logger,
+    })
+
+    expect(RETURNING_USER.id).toBeDefined()
+    expect(result.id).toBe(RETURNING_USER.id!)
+    expect(result.email).toBe(RETURNING_USER.email)
+    expect(mockGetUserInfoFromApiKey).toHaveBeenCalledTimes(1)
+  })
+})

package/src/__tests__/e2e-cli.test.ts

@@ -0,0 +1,183 @@
+import { spawn, spawnSync } from 'child_process'
+import path from 'path'
+
+import { describe, test, expect } from 'bun:test'
+import stripAnsi from 'strip-ansi'
+
+import { isSDKBuilt, ensureCliTestEnv } from './test-utils'
+
+const CLI_PATH = path.join(__dirname, '../index.tsx')
+const TIMEOUT_MS = 10000
+const sdkBuilt = isSDKBuilt()
+
+ensureCliTestEnv()
+
+function runCLI(
+  args: string[],
+): { stdout: string; stderr: string; exitCode: number | null } {
+  const result = spawnSync('bun', ['run', CLI_PATH, ...args], {
+    cwd: path.join(__dirname, '../..'),
+    timeout: TIMEOUT_MS,
+    env: process.env,
+  })
+  return {
+    stdout: result.stdout?.toString() ?? '',
+    stderr: result.stderr?.toString() ?? '',
+    exitCode: result.status,
+  }
+}
+
+describe.skipIf(!sdkBuilt)('CLI End-to-End Tests', () => {
+  test(
+    'CLI shows help with --help flag',
+    () => {
+      const { stdout, stderr, exitCode } = runCLI(['--help'])
+
+      const cleanOutput = stripAnsi(stdout + stderr)
+      expect(cleanOutput).toContain('--agent')
+      expect(cleanOutput).toContain('Usage:')
+      expect(exitCode).toBe(0)
+    },
+    TIMEOUT_MS,
+  )
+
+  test(
+    'CLI shows help with -h flag',
+    () => {
+      const { stdout, stderr, exitCode } = runCLI(['-h'])
+
+      const cleanOutput = stripAnsi(stdout + stderr)
+      expect(cleanOutput).toContain('--agent')
+      expect(exitCode).toBe(0)
+    },
+    TIMEOUT_MS,
+  )
+
+  test(
+    'CLI shows version with --version flag',
+    () => {
+      const { stdout, stderr, exitCode } = runCLI(['--version'])
+
+      const cleanOutput = stripAnsi(stdout + stderr)
+      expect(cleanOutput).toMatch(/\d+\.\d+\.\d+|dev/)
+      expect(exitCode).toBe(0)
+    },
+    TIMEOUT_MS,
+  )
+
+  test(
+    'CLI shows version with -v flag',
+    () => {
+      const { stdout, stderr, exitCode } = runCLI(['-v'])
+
+      const cleanOutput = stripAnsi(stdout + stderr)
+      expect(cleanOutput).toMatch(/\d+\.\d+\.\d+|dev/)
+      expect(exitCode).toBe(0)
+    },
+    TIMEOUT_MS,
+  )
+
+  test(
+    'CLI accepts --agent flag',
+    async () => {
+      // Verify the CLI starts without errors when given --agent flag.
+      // The CLI goes through full initialization (agent registry, skill registry,
+      // renderer creation) before producing any piped output, so we need a
+      // generous timeout. We also treat "process still alive" as success.
+      const proc = spawn('bun', ['run', CLI_PATH, '--agent', 'ask'], {
+        cwd: path.join(__dirname, '../..'),
+        stdio: 'pipe',
+      })
+
+      let started = false
+      let exitedEarly = false
+      proc.once('exit', () => {
+        if (!started) exitedEarly = true
+      })
+
+      await new Promise<void>((resolve) => {
+        const timeout = setTimeout(() => {
+          // Process is still alive after wait — it started successfully
+          if (!exitedEarly) started = true
+          resolve()
+        }, 8000)
+
+        proc.stdout?.once('data', () => {
+          started = true
+          clearTimeout(timeout)
+          resolve()
+        })
+        proc.stderr?.once('data', () => {
+          started = true
+          clearTimeout(timeout)
+          resolve()
+        })
+      })
+
+      proc.kill('SIGTERM')
+
+      expect(started).toBe(true)
+    },
+    TIMEOUT_MS,
+  )
+
+  test(
+    'CLI accepts --clear-logs flag',
+    async () => {
+      const proc = spawn('bun', ['run', CLI_PATH, '--clear-logs'], {
+        cwd: path.join(__dirname, '../..'),
+        stdio: 'pipe',
+      })
+
+      let started = false
+      let exitedEarly = false
+      proc.once('exit', () => {
+        if (!started) exitedEarly = true
+      })
+
+      await new Promise<void>((resolve) => {
+        const timeout = setTimeout(() => {
+          if (!exitedEarly) started = true
+          resolve()
+        }, 8000)
+
+        proc.stdout?.once('data', () => {
+          started = true
+          clearTimeout(timeout)
+          resolve()
+        })
+        proc.stderr?.once('data', () => {
+          started = true
+          clearTimeout(timeout)
+          resolve()
+        })
+      })
+
+      proc.kill('SIGTERM')
+
+      expect(started).toBe(true)
+    },
+    TIMEOUT_MS,
+  )
+
+  test(
+    'CLI handles invalid flags gracefully',
+    () => {
+      const { stderr, exitCode } = runCLI(['--invalid-flag'])
+
+      // Commander should show an error
+      expect(exitCode).not.toBe(0)
+      expect(stripAnsi(stderr)).toContain('error')
+    },
+    TIMEOUT_MS,
+  )
+})
+
+// Show message when SDK tests are skipped
+if (!sdkBuilt) {
+  describe('SDK Build Required', () => {
+    test.skip('Build SDK for E2E tests: cd sdk && bun run build', () => {
+      // This test is skipped to show the build instruction
+    })
+  })
+}