@alumbwe/anvil 1.0.0

package/src/__tests__/integration/usage-refresh-on-completion.test.ts

@@ -0,0 +1,168 @@
+import { QueryClient } from '@tanstack/react-query'
+import { describe, test, expect, beforeEach, afterEach, mock, spyOn } from 'bun:test'
+
+import { usageQueryKeys } from '../../hooks/use-usage-query'
+import { useChatStore } from '../../state/chat-store'
+import * as authModule from '../../utils/auth'
+
+/**
+ * Integration test for usage refresh on SDK run completion
+ *
+ * This test verifies the complete lifecycle:
+ * 1. User opens usage banner (inputMode = 'usage')
+ * 2. SDK run completes successfully
+ * 3. Query is invalidated to trigger refresh
+ * 4. Banner shows updated credit balance (when query refetches)
+ *
+ * Also tests:
+ * - No invalidation when banner is closed (inputMode = 'default')
+ * - Multiple sequential runs with banner open
+ */
+describe('Usage Refresh on SDK Completion', () => {
+  const originalFetch = globalThis.fetch
+  const originalEnv = process.env.NEXT_PUBLIC_ANVIL_APP_URL
+
+  let queryClient: QueryClient
+  let getAuthTokenSpy: ReturnType<typeof spyOn>
+
+  beforeEach(() => {
+    process.env.NEXT_PUBLIC_ANVIL_APP_URL = 'https://test.codebuff.local'
+
+    // Reset chat store to initial state
+    useChatStore.getState().reset()
+
+    // Create a fresh query client for each test
+    queryClient = new QueryClient({
+      defaultOptions: {
+        queries: { retry: false },
+      },
+    })
+
+    // Mock auth token
+    getAuthTokenSpy = spyOn(authModule, 'getAuthToken').mockReturnValue(
+      'test-token',
+    )
+
+    // Mock successful API response
+    globalThis.fetch = mock(
+      async () =>
+        new Response(
+          JSON.stringify({
+            type: 'usage-response',
+            usage: 100,
+            remainingBalance: 850,
+            next_quota_reset: '2024-03-01T00:00:00.000Z',
+          }),
+          { status: 200, headers: { 'Content-Type': 'application/json' } },
+        ),
+    ) as unknown as typeof fetch
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+    getAuthTokenSpy.mockRestore()
+    process.env.NEXT_PUBLIC_ANVIL_APP_URL = originalEnv
+    mock.restore()
+  })
+
+  describe('banner visible scenarios', () => {
+    test('should invalidate query when banner is visible and run completes', () => {
+      // Setup: Open usage banner
+      useChatStore.getState().setInputMode('usage')
+      expect(useChatStore.getState().inputMode).toBe('usage')
+
+      // Spy on invalidateQueries
+      const invalidateSpy = spyOn(queryClient, 'invalidateQueries')
+
+      // Simulate SDK run completion triggering invalidation
+      const isUsageMode = useChatStore.getState().inputMode === 'usage'
+      if (isUsageMode) {
+        queryClient.invalidateQueries({ queryKey: usageQueryKeys.current() })
+      }
+
+      // Verify: Query invalidation was called
+      expect(invalidateSpy).toHaveBeenCalledTimes(1)
+      expect(invalidateSpy.mock.calls[0][0]).toEqual({
+        queryKey: usageQueryKeys.current(),
+      })
+    })
+
+    test('should invalidate multiple times for sequential runs', () => {
+      useChatStore.getState().setInputMode('usage')
+
+      const invalidateSpy = spyOn(queryClient, 'invalidateQueries')
+
+      // Simulate three sequential SDK runs
+      for (let i = 0; i < 3; i++) {
+        if (useChatStore.getState().inputMode === 'usage') {
+          queryClient.invalidateQueries({ queryKey: usageQueryKeys.current() })
+        }
+      }
+
+      expect(invalidateSpy).toHaveBeenCalledTimes(3)
+    })
+  })
+
+  describe('banner not visible scenarios', () => {
+    test('should NOT invalidate when banner is not visible', () => {
+      // Setup: Banner is closed (default mode)
+      useChatStore.getState().setInputMode('default')
+      expect(useChatStore.getState().inputMode).toBe('default')
+
+      const invalidateSpy = spyOn(queryClient, 'invalidateQueries')
+
+      // Simulate SDK run completion check
+      const isUsageMode = useChatStore.getState().inputMode === 'usage'
+      if (isUsageMode) {
+        queryClient.invalidateQueries({ queryKey: usageQueryKeys.current() })
+      }
+
+      // Verify: No invalidation happened
+      expect(invalidateSpy).not.toHaveBeenCalled()
+    })
+
+    test('should not invalidate if banner was closed before run completed', () => {
+      // Setup: Start with banner open
+      useChatStore.getState().setInputMode('usage')
+
+      // User closes banner before run completes
+      useChatStore.getState().setInputMode('default')
+
+      const invalidateSpy = spyOn(queryClient, 'invalidateQueries')
+
+      // Simulate run completion
+      const isUsageMode = useChatStore.getState().inputMode === 'usage'
+      if (isUsageMode) {
+        queryClient.invalidateQueries({ queryKey: usageQueryKeys.current() })
+      }
+
+      expect(invalidateSpy).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('query behavior', () => {
+    test('should not fetch when enabled is false', () => {
+      // Even if banner is visible in store, query won't run if enabled=false
+      useChatStore.getState().setInputMode('usage')
+
+      const fetchSpy = spyOn(globalThis, 'fetch')
+
+      // Query with enabled=false won't execute
+      // (This would be the behavior when useUsageQuery({ enabled: false }) is called)
+
+      expect(fetchSpy).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('unauthenticated scenarios', () => {
+    test('should not fetch when no auth token', () => {
+      getAuthTokenSpy.mockReturnValue(undefined)
+      useChatStore.getState().setInputMode('usage')
+
+      const fetchSpy = spyOn(globalThis, 'fetch')
+
+      // Query won't execute without auth token
+      expect(fetchSpy).not.toHaveBeenCalled()
+    })
+  })
+})

package/src/__tests__/integration-tmux.test.ts

@@ -0,0 +1,188 @@
+import { spawn } from 'child_process'
+import path from 'path'
+
+import { describe, test, expect, beforeAll } from 'bun:test'
+import stripAnsi from 'strip-ansi'
+
+import {
+  isTmuxAvailable,
+  isSDKBuilt,
+  sleep,
+  ensureCliTestEnv,
+  getDefaultCliEnv,
+} from './test-utils'
+
+const CLI_PATH = path.join(__dirname, '../index.tsx')
+const TIMEOUT_MS = 15000
+
+// Establish the test environment before deciding whether tmux tests should
+// run. Otherwise file-loading order can make the full suite run these tests
+// locally even though the same suite normally marks itself as CI.
+ensureCliTestEnv()
+
+const tmuxAvailable = isTmuxAvailable()
+const sdkBuilt = isSDKBuilt()
+
+// 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}`))
+      }
+    })
+  })
+}
+
+describe.skipIf(!tmuxAvailable || !sdkBuilt)(
+  'CLI Integration Tests with tmux',
+  () => {
+    beforeAll(async () => {
+      if (!tmuxAvailable) {
+        console.log('\n⚠️  Skipping tmux tests - tmux not installed')
+        console.log(
+          '📦 Install with: brew install tmux (macOS) or sudo apt-get install tmux (Linux)\n',
+        )
+      }
+      if (!sdkBuilt) {
+        console.log('\n⚠️  Skipping tmux tests - SDK not built')
+        console.log('🔨 Build SDK: cd sdk && bun run build\n')
+      }
+      if (tmuxAvailable && sdkBuilt) {
+        const envVars = getDefaultCliEnv()
+        const entries = Object.entries(envVars)
+        // Propagate environment into tmux server so sessions inherit required vars
+        await Promise.all(
+          entries.map(([key, value]) =>
+            tmux(['set-environment', '-g', key, value]).catch(() => {
+              // Ignore failures; environment might already be set
+            }),
+          ),
+        )
+        // Clear FREEBUFF_MODE from the tmux global env. A previous freebuff
+        // build or `bun run dev:freebuff` invocation in the same tmux server
+        // can leave it set globally, which would make this test see the
+        // freebuff CLI variant (which has no `--agent` flag).
+        await tmux(['set-environment', '-gu', 'FREEBUFF_MODE']).catch(() => {})
+      }
+    })
+
+    test(
+      'CLI starts and displays help output',
+      async () => {
+        const sessionName = 'anvil-test-' + Date.now()
+
+        try {
+          // Create session with --help flag and keep it alive with '; sleep 2'
+          await tmux([
+            'new-session',
+            '-d',
+            '-s',
+            sessionName,
+            '-x',
+            '120',
+            '-y',
+            '30',
+            `bun run ${CLI_PATH} --help; sleep 2`,
+          ])
+
+          // Wait for output - give CLI time to start and render help
+          await sleep(800)
+
+          let cleanOutput = ''
+          for (let i = 0; i < 10; i += 1) {
+            await sleep(300)
+            const output = await tmux(['capture-pane', '-t', sessionName, '-p'])
+            cleanOutput = stripAnsi(output)
+            if (cleanOutput.includes('--agent')) {
+              break
+            }
+          }
+
+          expect(cleanOutput).toContain('--agent')
+          expect(cleanOutput).toContain('Usage:')
+        } finally {
+          // Cleanup
+          try {
+            await tmux(['kill-session', '-t', sessionName])
+          } catch {
+            // Session may have already exited
+          }
+        }
+      },
+      TIMEOUT_MS,
+    )
+
+    test(
+      'CLI accepts --agent flag',
+      async () => {
+        const sessionName = 'anvil-test-' + Date.now()
+
+        try {
+          // Start CLI with --agent flag (it will wait for input, so we can capture)
+          await tmux([
+            'new-session',
+            '-d',
+            '-s',
+            sessionName,
+            '-x',
+            '120',
+            '-y',
+            '30',
+            `bun run ${CLI_PATH} --agent ask`,
+          ])
+
+          let output = ''
+          for (let i = 0; i < 5; i += 1) {
+            await sleep(200)
+            output = await tmux(['capture-pane', '-t', sessionName, '-p'])
+            if (output.length > 0) {
+              break
+            }
+          }
+
+          // Should have started without errors
+          expect(output.length).toBeGreaterThan(0)
+        } finally {
+          try {
+            await tmux(['kill-session', '-t', sessionName])
+          } catch {
+            // Session may have already exited
+          }
+        }
+      },
+      TIMEOUT_MS,
+    )
+  },
+)
+
+// Always show installation message when tmux tests are skipped
+if (!tmuxAvailable) {
+  describe('tmux Installation Required', () => {
+    test.skip('Install tmux for interactive CLI tests', () => {
+      // This test is intentionally skipped to show the message
+    })
+  })
+}
+
+if (!sdkBuilt) {
+  describe('SDK Build Required', () => {
+    test.skip('Build SDK for integration tests: cd sdk && bun run build', () => {
+      // This test is intentionally skipped to show the message
+    })
+  })
+}