@alumbwe/anvil 1.0.0

package/src/__tests__/test-utils.ts

@@ -0,0 +1,271 @@
+import { execSync } from 'child_process'
+import fs from 'fs'
+import path from 'path'
+
+/**
+ * Check if tmux is available and usable on the system.
+ * This checks both that tmux is installed AND that it can actually run
+ * (e.g., the tmux server socket directory exists and is accessible).
+ *
+ * Returns false on CI unless ANVIL_RUN_TMUX_TESTS=1 explicitly opts into
+ * running deterministic tmux tests in a known terminal environment.
+ */
+export function isTmuxAvailable(): boolean {
+  // Skip on CI - tmux integration tests need a real terminal environment
+  if (
+    (process.env.CI === 'true' || process.env.CI === '1') &&
+    process.env.ANVIL_RUN_TMUX_TESTS !== '1'
+  ) {
+    return false
+  }
+
+  try {
+    // First check if tmux is installed
+    execSync('which tmux', { stdio: 'pipe' })
+    // Then verify tmux can actually run by creating and killing a test session
+    // This will fail if tmux server can't start (e.g., no socket directory on CI)
+    execSync('tmux new-session -d -s __anvil_tmux_check__ && tmux kill-session -t __anvil_tmux_check__', {
+      stdio: 'pipe',
+      timeout: 5000,
+    })
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Check if the SDK is built by checking for the dist directory
+ */
+export function isSDKBuilt(): boolean {
+  try {
+    const sdkDistDir = path.join(__dirname, '../../../sdk/dist')
+    const possibleArtifacts = ['index.js', 'index.mjs', 'index.cjs']
+    return possibleArtifacts.some((file) =>
+      fs.existsSync(path.join(sdkDistDir, file)),
+    )
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Sleep utility for async delays
+ */
+export const sleep = (ms: number) =>
+  new Promise((resolve) => setTimeout(resolve, ms))
+
+let cachedEnv: Record<string, string> | null = null
+
+const TEST_CLIENT_ENV_DEFAULTS: Record<string, string> = {
+  NEXT_PUBLIC_CB_ENVIRONMENT: 'test',
+  NEXT_PUBLIC_ANVIL_APP_URL: 'http://localhost:3000',
+  NEXT_PUBLIC_SUPPORT_EMAIL: 'support@codebuff.com',
+  NEXT_PUBLIC_POSTHOG_API_KEY: 'test-posthog-key',
+  NEXT_PUBLIC_POSTHOG_HOST_URL: 'https://us.i.posthog.com',
+  NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY: 'pk_test_placeholder',
+  NEXT_PUBLIC_STRIPE_CUSTOMER_PORTAL:
+    'https://billing.stripe.com/p/login/test_placeholder',
+  NEXT_PUBLIC_GOOGLE_SITE_VERIFICATION_ID: 'test-verification',
+  NEXT_PUBLIC_WEB_PORT: '3000',
+}
+const TEST_SERVER_ENV_DEFAULTS: Record<string, string> = {
+  OPEN_ROUTER_API_KEY: 'test',
+  OPENAI_API_KEY: 'test',
+  ANTHROPIC_API_KEY: 'test',
+  SERPER_API_KEY: 'test',
+  GRAVITY_API_KEY: 'test',
+  GRAVITY_CAPI_KEY: 'test',
+  PORT: '4242',
+  DATABASE_URL: 'postgres://user:pass@localhost:5432/db',
+  ANVIL_GITHUB_ID: 'test-id',
+  ANVIL_GITHUB_SECRET: 'test-secret',
+  NEXTAUTH_SECRET: 'test-secret',
+  STRIPE_SECRET_KEY: 'sk_test_dummy',
+  STRIPE_WEBHOOK_SECRET_KEY: 'whsec_dummy',
+  STRIPE_TEAM_FEE_PRICE_ID: 'price_test',
+  LOOPS_API_KEY: 'test',
+  DISCORD_PUBLIC_KEY: 'test',
+  DISCORD_BOT_TOKEN: 'test',
+  DISCORD_APPLICATION_ID: 'test',
+}
+
+function ensureCliEnvDefaults(): void {
+  if (!process.env.NODE_ENV) {
+    process.env.NODE_ENV = 'test'
+  }
+  if (!process.env.BUN_ENV) {
+    process.env.BUN_ENV = 'test'
+  }
+  if (process.env.CI !== 'true' && process.env.CI !== '1') {
+    process.env.CI = 'true'
+  }
+
+  for (const [key, value] of Object.entries(TEST_CLIENT_ENV_DEFAULTS)) {
+    if (!process.env[key]) {
+      process.env[key] = value
+    }
+  }
+
+  for (const [key, value] of Object.entries(TEST_SERVER_ENV_DEFAULTS)) {
+    if (!process.env[key]) {
+      process.env[key] = value
+    }
+  }
+}
+
+function loadCliEnv(): Record<string, string> {
+  if (cachedEnv) {
+    return cachedEnv
+  }
+
+  try {
+    ensureCliEnvDefaults()
+    // NOTE: Inline require() is used for lazy loading - the env module depends on
+    // Infisical secrets which may not be available at module load time in test environments
+    const { env } = require('../../../packages/internal/src/env') as {
+      env: Record<string, unknown>
+    }
+
+    cachedEnv = Object.entries(env).reduce<Record<string, string>>(
+      (acc, [key, value]) => {
+        if (value !== undefined && value !== null) {
+          acc[key] = String(value)
+        }
+        return acc
+      },
+      {},
+    )
+
+    return cachedEnv
+  } catch (error) {
+    const message =
+      error instanceof Error
+        ? error.message
+        : 'unknown error loading environment'
+    throw new Error(
+      `Failed to load CLI environment via packages/internal/src/env: ${message}. ` +
+        'Run commands via "infisical run -- bun …" or export the required variables.',
+    )
+  }
+}
+
+export function ensureCliTestEnv(): void {
+  loadCliEnv()
+}
+
+export function getDefaultCliEnv(): Record<string, string> {
+  return { ...loadCliEnv() }
+}
+
+/**
+ * Parsed re-render log entry from useWhyDidYouUpdate hook
+ */
+export interface RerenderLogEntry {
+  timestamp: string
+  componentName: string
+  messageId: string
+  renderCount: number
+  changedProps: string[]
+}
+
+/**
+ * Aggregated re-render analysis results
+ */
+export interface RerenderAnalysis {
+  totalRerenders: number
+  rerendersByMessage: Map<string, number>
+  propChangeFrequency: Map<string, number>
+  maxRerenderPerMessage: number
+}
+
+/**
+ * Parse re-render logs from the CLI debug log file
+ */
+export function parseRerenderLogs(logPath: string): RerenderLogEntry[] {
+  const entries: RerenderLogEntry[] = []
+
+  try {
+    const content = fs.readFileSync(logPath, 'utf-8')
+    const lines = content.split('\n').filter((line) => line.trim())
+
+    for (const line of lines) {
+      try {
+        const parsed = JSON.parse(line)
+
+        // Check if this is a re-render log entry
+        if (
+          parsed.msg &&
+          typeof parsed.msg === 'string' &&
+          parsed.msg.includes('render #')
+        ) {
+          // Extract component name from msg like "MessageBlock render #2 [user-123]: 2 props changed"
+          const msgMatch = parsed.msg.match(
+            /^(\w+) render #(\d+) \[([^\]]+)\]/,
+          )
+          if (msgMatch && parsed.data) {
+            entries.push({
+              timestamp: parsed.timestamp,
+              componentName: msgMatch[1],
+              messageId: parsed.data.id || msgMatch[3],
+              renderCount: parseInt(msgMatch[2], 10),
+              changedProps: parsed.data.changedProps || [],
+            })
+          }
+        }
+      } catch {
+        // Skip malformed lines
+      }
+    }
+  } catch {
+    // File doesn't exist or can't be read
+  }
+
+  return entries
+}
+
+/**
+ * Analyze re-render logs and return aggregated statistics
+ */
+export function analyzeRerenders(entries: RerenderLogEntry[]): RerenderAnalysis {
+  const rerendersByMessage = new Map<string, number>()
+  const propChangeFrequency = new Map<string, number>()
+
+  for (const entry of entries) {
+    // Count re-renders per message
+    const currentCount = rerendersByMessage.get(entry.messageId) || 0
+    rerendersByMessage.set(entry.messageId, currentCount + 1)
+
+    // Count how often each prop changes
+    for (const prop of entry.changedProps) {
+      const propCount = propChangeFrequency.get(prop) || 0
+      propChangeFrequency.set(prop, propCount + 1)
+    }
+  }
+
+  // Find max re-renders for any single message
+  let maxRerenderPerMessage = 0
+  for (const count of rerendersByMessage.values()) {
+    if (count > maxRerenderPerMessage) {
+      maxRerenderPerMessage = count
+    }
+  }
+
+  return {
+    totalRerenders: entries.length,
+    rerendersByMessage,
+    propChangeFrequency,
+    maxRerenderPerMessage,
+  }
+}
+
+/**
+ * Clear the CLI debug log file
+ */
+export function clearCliDebugLog(logPath: string): void {
+  try {
+    fs.writeFileSync(logPath, '')
+  } catch {
+    // Ignore errors
+  }
+}

package/src/__tests__/tmux-poc.ts

@@ -0,0 +1,150 @@
+#!/usr/bin/env bun
+
+/**
+ * Proof of Concept: tmux-based CLI testing
+ *
+ * This script demonstrates how to:
+ * 1. Create a tmux session
+ * 2. Run the CLI in that session
+ * 3. Send commands to the CLI
+ * 4. Capture and verify output
+ * 5. Clean up the session
+ */
+
+import { spawn } from 'child_process'
+
+import stripAnsi from 'strip-ansi'
+
+import { isTmuxAvailable, sleep } from './test-utils'
+
+// Utility to run tmux commands
+function tmux(args: string[]): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const proc = spawn('tmux', args, { stdio: 'pipe' })
+    let stdout = ''
+    let stderr = ''
+
+    proc.stdout?.on('data', (data) => {
+      stdout += data.toString()
+    })
+
+    proc.stderr?.on('data', (data) => {
+      stderr += data.toString()
+    })
+
+    proc.on('close', (code) => {
+      if (code === 0) {
+        resolve(stdout)
+      } else {
+        reject(new Error(`tmux command failed: ${stderr}`))
+      }
+    })
+  })
+}
+
+// Capture pane content
+async function capturePane(sessionName: string): Promise<string> {
+  return await tmux(['capture-pane', '-t', sessionName, '-p'])
+}
+
+// Main test function
+async function testCLIWithTmux() {
+  const sessionName = 'anvil-test-' + Date.now()
+
+  console.log('🚀 Starting tmux-based CLI test...')
+  console.log(`📦 Session: ${sessionName}`)
+
+  // 1. Check if tmux is installed
+  if (!isTmuxAvailable()) {
+    console.error('❌ tmux not found')
+    console.error('\n📦 Installation:')
+    console.error('  macOS:   brew install tmux')
+    console.error('  Ubuntu:  sudo apt-get install tmux')
+    console.error('  Windows: Use WSL and run sudo apt-get install tmux')
+    console.error(
+      '\nℹ️  This is just a proof-of-concept. See the documentation for alternatives.',
+    )
+    process.exit(1)
+  }
+
+  try {
+    const version = await tmux(['-V'])
+    console.log(`✅ tmux is installed: ${version.trim()}`)
+
+    // 2. Create new detached tmux session running the CLI
+    console.log('\n📺 Creating tmux session...')
+    await tmux([
+      'new-session',
+      '-d',
+      '-s',
+      sessionName,
+      '-x',
+      '120', // width
+      '-y',
+      '30', // height
+      'bun',
+      'run',
+      'src/entry.ts',
+      '--help',
+    ])
+    console.log('✅ Session created')
+
+    // 3. Wait for CLI to start
+    await sleep(1000)
+
+    // 4. Capture initial output
+    console.log('\n📸 Capturing initial output...')
+    const initialOutput = await capturePane(sessionName)
+    const cleanOutput = stripAnsi(initialOutput)
+
+    console.log('\n--- Output ---')
+    console.log(cleanOutput)
+    console.log('--- End Output ---\n')
+
+    // 5. Verify output contains expected text
+    const checks = [
+      { text: '--agent', pass: cleanOutput.includes('--agent') },
+      { text: 'Usage:', pass: cleanOutput.includes('Usage:') },
+      { text: '--help', pass: cleanOutput.includes('--help') },
+    ]
+
+    console.log('🔍 Verification:')
+    checks.forEach(({ text, pass }) => {
+      console.log(
+        `  ${pass ? '✅' : '❌'} Contains "${text}"${pass ? '' : ' - NOT FOUND'}`,
+      )
+    })
+
+    const allPassed = checks.every((c) => c.pass)
+    console.log(
+      `\n${allPassed ? '🎉 All checks passed!' : '⚠️  Some checks failed'}`,
+    )
+
+    // 6. Example: Send interactive command (commented out for --help test)
+    /*
+    console.log('\n⌨️  Sending test command...')
+    await sendKeys(sessionName, 'hello world')
+    await sendKeys(sessionName, 'Enter')
+    await sleep(2000)
+    
+    const responseOutput = await capturePane(sessionName)
+    console.log('\n--- Response ---')
+    console.log(stripAnsi(responseOutput))
+    console.log('--- End Response ---')
+    */
+  } catch (error) {
+    console.error('\n❌ Test failed:', error)
+  } finally {
+    // 7. Cleanup: kill the tmux session
+    console.log('\n🧹 Cleaning up...')
+    try {
+      await tmux(['kill-session', '-t', sessionName])
+      console.log('✅ Session cleaned up')
+    } catch (e) {
+      console.log('⚠️  Session may have already exited')
+    }
+  }
+}
+
+// Run the test
+testCLIWithTmux().catch(console.error)

package/src/__tests__/unit/agent-mode-toggle.test.ts

@@ -0,0 +1,137 @@
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test'
+
+import {
+  buildExpandedSegments,
+  resolveAgentModeClick,
+  OPEN_DELAY_MS,
+  CLOSE_DELAY_MS,
+  REOPEN_SUPPRESS_MS,
+} from '../../components/agent-mode-toggle'
+import { createHoverToggleControllerForTest } from '../mocks/hover-toggle-controller'
+
+import type { AgentMode } from '../../utils/constants'
+
+describe('AgentModeToggle - buildExpandedSegments', () => {
+  const modes: AgentMode[] = ['DEFAULT', 'MAX', 'PLAN']
+
+  for (const mode of modes) {
+    test(`returns segments with active indicator for ${mode}`, () => {
+      const segs = buildExpandedSegments(mode)
+      // 4 mode options (DEFAULT, LITE, MAX, PLAN) + 1 active indicator
+      expect(segs.length).toBe(5)
+
+      // Current mode is disabled among the choices
+      const current = segs.find((s) => s.id === mode)
+      expect(current?.disabled).toBe(true)
+
+      // Active indicator has expected id and flags
+      const active = segs.find((s) => s.id === `active-${mode}`)
+      expect(active).toBeTruthy()
+      expect(active?.isSelected).toBe(true)
+      expect(active?.defaultHighlighted).toBe(true)
+    })
+  }
+})
+
+describe('AgentModeToggle - resolveAgentModeClick', () => {
+  test('clicking active indicator returns closeActive', () => {
+    const action = resolveAgentModeClick('DEFAULT', 'active-DEFAULT', true)
+    expect(action).toEqual({ type: 'closeActive' })
+  })
+
+  test('with onSelectMode provided, clicking different mode selects it', () => {
+    const action = resolveAgentModeClick('DEFAULT', 'MAX', true)
+    expect(action).toEqual({ type: 'selectMode', mode: 'MAX' })
+  })
+
+  test('without onSelectMode, clicking different mode toggles', () => {
+    const action = resolveAgentModeClick('DEFAULT', 'PLAN', false)
+    expect(action).toEqual({ type: 'toggleMode', mode: 'PLAN' })
+  })
+})
+
+// Extended Date.now type with test helper method
+interface MockDateNow {
+  (): number
+  set: (v: number) => void
+}
+
+describe('useHoverToggle timing (controller)', () => {
+  let originalSetTimeout: typeof setTimeout
+  let originalClearTimeout: typeof clearTimeout
+  let originalNow: typeof Date.now
+
+  let timers: { id: number; ms: number; fn: () => void; active: boolean }[]
+  let nextId: number
+
+  const runAll = () => {
+    for (const t of timers) {
+      if (t.active) t.fn()
+    }
+    timers = []
+  }
+
+  beforeEach(() => {
+    timers = []
+    nextId = 1
+    originalSetTimeout = setTimeout
+    originalClearTimeout = clearTimeout
+    originalNow = Date.now
+
+    let now = 1_000
+    const mockDateNow: MockDateNow = Object.assign(
+      () => now,
+      { set: (v: number) => { now = v } }
+    )
+    Date.now = mockDateNow
+
+    globalThis.setTimeout = ((fn: () => void, ms?: number) => {
+      const id = nextId++
+      timers.push({ id, ms: Number(ms ?? 0), fn, active: true })
+      return id as unknown as ReturnType<typeof setTimeout>
+    }) as typeof setTimeout
+
+    globalThis.clearTimeout = ((id?: ReturnType<typeof clearTimeout>) => {
+      const rec = timers.find((t) => t.id === (id as unknown as number))
+      if (rec) rec.active = false
+    }) as typeof clearTimeout
+  })
+
+  afterEach(() => {
+    globalThis.setTimeout = originalSetTimeout
+    globalThis.clearTimeout = originalClearTimeout
+    Date.now = originalNow
+  })
+
+  test('scheduleOpen waits OPEN_DELAY_MS then opens', () => {
+    const ctl = createHoverToggleControllerForTest()
+    expect(ctl.isOpen).toBe(false)
+    ctl.scheduleOpen()
+    expect(timers.length).toBe(1)
+    expect(timers[0].ms).toBe(OPEN_DELAY_MS)
+    runAll()
+    expect(ctl.isOpen).toBe(true)
+  })
+
+  test('scheduleClose waits CLOSE_DELAY_MS then closes', () => {
+    const ctl = createHoverToggleControllerForTest()
+    ctl.openNow()
+    expect(ctl.isOpen).toBe(true)
+    ctl.scheduleClose()
+    expect(timers.length).toBe(1)
+    expect(timers[0].ms).toBe(CLOSE_DELAY_MS)
+    runAll()
+    expect(ctl.isOpen).toBe(false)
+  })
+
+  test('closeNow(true) suppresses reopen until time passes', () => {
+    const ctl = createHoverToggleControllerForTest()
+    ctl.closeNow(true)
+    ctl.scheduleOpen()
+    expect(timers.length).toBe(0)
+    ;(Date.now as MockDateNow).set(1_000 + REOPEN_SUPPRESS_MS + 1)
+    ctl.scheduleOpen()
+    expect(timers.length).toBe(1)
+    expect(timers[0].ms).toBe(OPEN_DELAY_MS)
+  })
+})

package/src/__tests__/unit/copy-button.test.ts

@@ -0,0 +1,157 @@
+import { createMockTimers } from '@anvil/common/testing/mocks/timers'
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test'
+
+import {
+  getCopyIconText,
+  copyButtonHandlers,
+  COPIED_RESET_DELAY_MS,
+  COPY_ICON_COLLAPSED,
+  COPY_ICON_EXPANDED,
+  COPY_ICON_COPIED,
+} from '../../components/copy-button'
+import { initializeThemeStore } from '../../hooks/use-theme'
+
+import type { MockTimers } from '@anvil/common/testing/mocks/timers'
+
+// Initialize theme before tests
+initializeThemeStore()
+
+/**
+ * Tests for CopyButton component logic.
+ *
+ * These tests use the exported utilities from copy-button.tsx:
+ * - getCopyIconText: determines what text to display
+ * - copyButtonHandlers: pure functions for state transitions
+ * - COPIED_RESET_DELAY_MS: the timeout constant
+ */
+
+describe('CopyButton - CopyIcon text rendering', () => {
+  describe('with leadingSpace=true (default)', () => {
+    test('renders collapsed icon when not hovered or copied', () => {
+      const text = getCopyIconText(false, false, true)
+      expect(text).toBe(' ⎘')
+    })
+
+    test('renders expanded text when hovered', () => {
+      const text = getCopyIconText(false, true, true)
+      expect(text).toBe(' [⎘ copy]')
+    })
+
+    test('renders copied text when copied', () => {
+      const text = getCopyIconText(true, false, true)
+      expect(text).toBe(' [✔ copied]')
+    })
+
+    test('renders copied text even when hovered (copied takes priority)', () => {
+      const text = getCopyIconText(true, true, true)
+      expect(text).toBe(' [✔ copied]')
+    })
+  })
+
+  describe('with leadingSpace=false', () => {
+    test('renders collapsed icon without leading space', () => {
+      const text = getCopyIconText(false, false, false)
+      expect(text).toBe('⎘')
+    })
+
+    test('renders expanded text without leading space', () => {
+      const text = getCopyIconText(false, true, false)
+      expect(text).toBe('[⎘ copy]')
+    })
+
+    test('renders copied text without leading space', () => {
+      const text = getCopyIconText(true, false, false)
+      expect(text).toBe('[✔ copied]')
+    })
+  })
+})
+
+describe('CopyButton - copyButtonHandlers (from component)', () => {
+  describe('handleMouseOver', () => {
+    test('returns true (should hover) when not copied', () => {
+      expect(copyButtonHandlers.handleMouseOver(false)).toBe(true)
+    })
+
+    test('returns false (block hover) when copied', () => {
+      expect(copyButtonHandlers.handleMouseOver(true)).toBe(false)
+    })
+  })
+
+  describe('handleMouseOut', () => {
+    test('always returns false to clear hover', () => {
+      expect(copyButtonHandlers.handleMouseOut()).toBe(false)
+    })
+  })
+
+  describe('handleCopy', () => {
+    test('returns copied=true and clears hover', () => {
+      const result = copyButtonHandlers.handleCopy()
+      expect(result).toEqual({ isCopied: true, isHovered: false })
+    })
+  })
+})
+
+describe('CopyButton - exported constants', () => {
+  test('COPIED_RESET_DELAY_MS is 2000ms', () => {
+    expect(COPIED_RESET_DELAY_MS).toBe(2000)
+  })
+
+  test('icon constants are defined', () => {
+    expect(COPY_ICON_COLLAPSED).toBe('⎘')
+    expect(COPY_ICON_EXPANDED).toBe('[⎘ copy]')
+    expect(COPY_ICON_COPIED).toBe('[✔ copied]')
+  })
+})
+
+describe('CopyButton - copied state reset timing', () => {
+  let mockTimers: MockTimers
+
+  beforeEach(() => {
+    mockTimers = createMockTimers()
+    mockTimers.install()
+  })
+
+  afterEach(() => {
+    mockTimers.restore()
+  })
+
+  test('uses the exported COPIED_RESET_DELAY_MS constant (2000ms)', () => {
+    let isCopied = false
+
+    // Simulate handleCopy using the exported constant
+    const handleCopy = () => {
+      const newState = copyButtonHandlers.handleCopy()
+      isCopied = newState.isCopied
+      setTimeout(() => {
+        isCopied = false
+      }, COPIED_RESET_DELAY_MS)
+    }
+
+    handleCopy()
+    expect(isCopied).toBe(true)
+    expect(mockTimers.getPendingCount()).toBe(1)
+    const nextTimer = mockTimers.getNext()
+    expect(nextTimer?.ms).toBe(COPIED_RESET_DELAY_MS)
+
+    mockTimers.runAll()
+    expect(isCopied).toBe(false)
+  })
+
+  test('multiple rapid clicks only create one active timer', () => {
+    let currentTimerId: number | null = null
+
+    const handleCopy = () => {
+      if (currentTimerId !== null) {
+        clearTimeout(currentTimerId)
+      }
+      copyButtonHandlers.handleCopy()
+      currentTimerId = setTimeout(() => {}, COPIED_RESET_DELAY_MS) as unknown as number
+    }
+
+    handleCopy()
+    handleCopy()
+    handleCopy()
+
+    expect(mockTimers.getPendingCount()).toBe(1)
+  })
+})