@alumbwe/anvil 1.0.0 → 1.0.2

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

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

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

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

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