@alumbwe/anvil 1.0.0 → 1.0.2

package/src/__tests__/integration/login-flow-instrumentation.test.ts

@@ -1,134 +0,0 @@
-import { describe, test, expect, mock } from 'bun:test'
-
-import { AnalyticsEvent } from '@anvil/common/constants/analytics-events'
-import { createMockLogger } from '@anvil/common/testing/mock-types'
-
-import { generateLoginUrl, pollLoginStatus } from '../../login/login-flow'
-import { createMockApiClient } from '../helpers/mock-api-client'
-
-import type { ApiResponse } from '../../utils/anvil-api'
-
-const createClock = () => {
-  let current = 0
-  return {
-    sleep: async (ms: number) => {
-      current += ms
-    },
-    now: () => current,
-  }
-}
-
-// Typed so `.mock.calls[i]` is `[AnalyticsEvent, props?]` rather than the empty
-// tuple inferred from `mock(() => {})` (which makes indexing a type error).
-const createTrackEventMock = () =>
-  mock((_event: AnalyticsEvent, _properties?: Record<string, any>) => {})
-
-describe('login-flow analytics instrumentation', () => {
-  test('generateLoginUrl emits LOGIN_STARTED on entry and nothing else on success', async () => {
-    const trackEvent = createTrackEventMock()
-    const loginCode = mock(async () => ({
-      ok: true as const,
-      status: 200,
-      data: {
-        loginUrl: 'https://cli.test/login?code=abc',
-        fingerprintHash: 'hash-1',
-        expiresAt: '2030-01-01T00:00:00Z',
-      },
-    }))
-    const apiClient = createMockApiClient({ loginCode })
-
-    await generateLoginUrl(
-      { logger: createMockLogger(), apiClient, trackEvent },
-      { baseUrl: 'https://cli.test', fingerprintId: 'finger-1', via: 'modal' },
-    )
-
-    expect(trackEvent).toHaveBeenCalledTimes(1)
-    expect(trackEvent.mock.calls[0][0]).toBe(AnalyticsEvent.LOGIN_STARTED)
-    expect(trackEvent.mock.calls[0][1]).toEqual({ via: 'modal' })
-  })
-
-  test('generateLoginUrl emits LOGIN_FAILED with reason on a failed URL request', async () => {
-    const trackEvent = createTrackEventMock()
-    const loginCode = mock(
-      async () =>
-        ({ ok: false, status: 500, error: 'boom' }) as ApiResponse<never>,
-    )
-    const apiClient = createMockApiClient({ loginCode })
-
-    await expect(
-      generateLoginUrl(
-        { logger: createMockLogger(), apiClient, trackEvent },
-        {
-          baseUrl: 'https://cli.test',
-          fingerprintId: 'finger-1',
-          via: 'plain_command',
-        },
-      ),
-    ).rejects.toThrow()
-
-    // Two events: the initial LOGIN_STARTED and then LOGIN_FAILED. Match on the
-    // payload rather than the enum identity so the assertion is unambiguous.
-    expect(trackEvent).toHaveBeenCalledTimes(2)
-    expect(trackEvent.mock.calls[0][1]).toEqual({ via: 'plain_command' })
-    const failedCall = trackEvent.mock.calls.find(
-      (c) => c[1]?.reason === 'url_request',
-    )
-    expect(failedCall).toBeDefined()
-    expect(failedCall![1]).toEqual({
-      via: 'plain_command',
-      reason: 'url_request',
-      status: 500,
-    })
-  })
-
-  test('pollLoginStatus emits LOGIN_TIMEOUT with attempts + via', async () => {
-    const trackEvent = createTrackEventMock()
-    const loginStatus = mock(
-      async () => ({ ok: false, status: 401 }) as ApiResponse<{ user?: unknown }>,
-    )
-    const apiClient = createMockApiClient({ loginStatus })
-    const clock = createClock()
-
-    const result = await pollLoginStatus(
-      { sleep: clock.sleep, logger: createMockLogger(), now: clock.now, apiClient, trackEvent },
-      {
-        baseUrl: 'https://cli.test',
-        fingerprintId: 'finger-1',
-        fingerprintHash: 'hash-1',
-        expiresAt: '2030-01-01T00:00:00Z',
-        intervalMs: 10,
-        timeoutMs: 30,
-        via: 'modal',
-      },
-    )
-
-    expect(result.status).toBe('timeout')
-    expect(trackEvent).toHaveBeenCalledTimes(1)
-    expect(trackEvent.mock.calls[0][0]).toBe(AnalyticsEvent.LOGIN_TIMEOUT)
-    expect(trackEvent.mock.calls[0][1]).toMatchObject({ via: 'modal' })
-    expect(trackEvent.mock.calls[0][1]!.attempts).toBeGreaterThan(0)
-  })
-
-  test('pollLoginStatus emits LOGIN_ABORTED when shouldContinue is false', async () => {
-    const trackEvent = createTrackEventMock()
-    const apiClient = createMockApiClient()
-    const clock = createClock()
-
-    const result = await pollLoginStatus(
-      { sleep: clock.sleep, logger: createMockLogger(), now: clock.now, apiClient, trackEvent },
-      {
-        baseUrl: 'https://cli.test',
-        fingerprintId: 'finger-1',
-        fingerprintHash: 'hash-1',
-        expiresAt: '2030-01-01T00:00:00Z',
-        shouldContinue: () => false,
-        via: 'modal',
-      },
-    )
-
-    expect(result.status).toBe('aborted')
-    expect(trackEvent).toHaveBeenCalledTimes(1)
-    expect(trackEvent.mock.calls[0][0]).toBe(AnalyticsEvent.LOGIN_ABORTED)
-    expect(trackEvent.mock.calls[0][1]).toMatchObject({ via: 'modal' })
-  })
-})

package/src/__tests__/integration/login-polling-working.test.ts

@@ -1,285 +0,0 @@
-import { describe, test, expect, mock } from 'bun:test'
-
-import { createMockLogger } from '@anvil/common/testing/mock-types'
-import { generateLoginUrl, pollLoginStatus } from '../../login/login-flow'
-import { createMockApiClient } from '../helpers/mock-api-client'
-
-import type { LoginUrlResponse } from '../../login/login-flow'
-import type { ApiResponse } from '../../utils/anvil-api'
-import type { Logger } from '@anvil/common/types/contracts/logger'
-
-const createClock = () => {
-  let current = 0
-  return {
-    sleep: async (ms: number) => {
-      current += ms
-    },
-    now: () => current,
-  }
-}
-
-describe('Login Polling (Working)', () => {
-  test('P0: Polling Lifecycle - should stop polling and return user when login succeeds', async () => {
-    const logger = createMockLogger()
-    const apiResponses: Array<ApiResponse<{ user?: unknown }>> = [
-      { ok: false, status: 401 },
-      {
-        ok: true,
-        status: 200,
-        data: { user: { id: 'u1', name: 'Test User', email: 'user@test.dev' } },
-      },
-    ]
-    let callIndex = 0
-    const loginStatusMock = mock(
-      async (req: {
-        fingerprintId: string
-        fingerprintHash: string
-        expiresAt: string
-      }) => {
-        expect(req.fingerprintId).toBe('finger-1')
-        expect(req.fingerprintHash).toBe('hash-1')
-        expect(req.expiresAt).toBe('2030-01-01T00:00:00Z')
-        const response =
-          apiResponses[Math.min(callIndex, apiResponses.length - 1)]
-        callIndex += 1
-        return response
-      },
-    )
-
-    const apiClient = createMockApiClient({ loginStatus: loginStatusMock })
-    const clock = createClock()
-
-    const result = await pollLoginStatus(
-      {
-        sleep: clock.sleep,
-        logger,
-        now: clock.now,
-        apiClient,
-      },
-      {
-        baseUrl: 'https://cli.test',
-        fingerprintId: 'finger-1',
-        fingerprintHash: 'hash-1',
-        expiresAt: '2030-01-01T00:00:00Z',
-        intervalMs: 10,
-        timeoutMs: 200,
-      },
-    )
-
-    expect(result.status).toBe('success')
-    if (result.status !== 'success') {
-      throw new Error(`Expected polling success but received ${result.status}`)
-    }
-    expect(result.attempts).toBe(2)
-    expect(loginStatusMock.mock.calls.length).toBe(2)
-  })
-
-  test('P0: Polling Lifecycle - should keep polling on 401 responses', async () => {
-    const logger = createMockLogger()
-    const loginStatusMock = mock(async () => {
-      return { ok: false, status: 401 } as ApiResponse<{ user?: unknown }>
-    })
-
-    const apiClient = createMockApiClient({ loginStatus: loginStatusMock })
-    const clock = createClock()
-    const result = await pollLoginStatus(
-      {
-        sleep: clock.sleep,
-        logger,
-        now: clock.now,
-        apiClient,
-      },
-      {
-        baseUrl: 'https://cli.test',
-        fingerprintId: 'finger-2',
-        fingerprintHash: 'hash-2',
-        expiresAt: '2030-01-01T00:00:00Z',
-        intervalMs: 10,
-        timeoutMs: 50,
-      },
-    )
-
-    expect(result.status).toBe('timeout')
-    expect(loginStatusMock.mock.calls.length).toBeGreaterThan(1)
-  })
-
-  test('P0: Polling Lifecycle - should call loginStatus with full metadata', async () => {
-    const logger = createMockLogger()
-    const loginStatusMock = mock(
-      async (req: {
-        fingerprintId: string
-        fingerprintHash: string
-        expiresAt: string
-      }) => {
-        expect(req.fingerprintId).toBe('finger-meta')
-        expect(req.fingerprintHash).toBe('hash-meta')
-        expect(req.expiresAt).toBe('2030-01-01T00:00:00Z')
-        return {
-          ok: true,
-          status: 200,
-          data: {
-            user: { id: 'u-meta', name: 'Meta User', email: 'meta@test.dev' },
-          },
-        } as ApiResponse<{ user?: unknown }>
-      },
-    )
-
-    const apiClient = createMockApiClient({ loginStatus: loginStatusMock })
-    const clock = createClock()
-    const result = await pollLoginStatus(
-      {
-        sleep: clock.sleep,
-        logger,
-        now: clock.now,
-        apiClient,
-      },
-      {
-        baseUrl: 'https://cli.test',
-        fingerprintId: 'finger-meta',
-        fingerprintHash: 'hash-meta',
-        expiresAt: '2030-01-01T00:00:00Z',
-        intervalMs: 5,
-        timeoutMs: 50,
-      },
-    )
-
-    expect(result.status).toBe('success')
-    if (result.status !== 'success') {
-      throw new Error(`Expected polling success but received ${result.status}`)
-    }
-    expect(loginStatusMock.mock.calls.length).toBe(1)
-  })
-
-  test('P1: Error Handling - should log warnings on non-401 responses but continue polling', async () => {
-    const logger = createMockLogger()
-    const loginStatusMock = mock(async () => {
-      return { ok: false, status: 500, error: 'Server Error' } as ApiResponse<{
-        user?: unknown
-      }>
-    })
-
-    const apiClient = createMockApiClient({ loginStatus: loginStatusMock })
-    const clock = createClock()
-    const result = await pollLoginStatus(
-      {
-        sleep: clock.sleep,
-        logger,
-        now: clock.now,
-        apiClient,
-      },
-      {
-        baseUrl: 'https://cli.test',
-        fingerprintId: 'finger-error',
-        fingerprintHash: 'hash-error',
-        expiresAt: '2030-01-01T00:00:00Z',
-        intervalMs: 5,
-        timeoutMs: 25,
-      },
-    )
-
-    expect(result.status).toBe('timeout')
-    expect(logger.warn.mock.calls.length).toBeGreaterThan(0)
-  })
-
-  test('P1: Error Handling - should swallow network errors and keep polling', async () => {
-    const logger = createMockLogger()
-    let attempt = 0
-    const loginStatusMock = mock(async () => {
-      attempt += 1
-      if (attempt === 1) {
-        return { ok: false, status: 401 } as ApiResponse<{ user?: unknown }>
-      }
-      if (attempt === 2) {
-        throw new Error('network failed')
-      }
-      return {
-        ok: true,
-        status: 200,
-        data: {
-          user: { id: 'user', name: 'Network User', email: 'net@test.dev' },
-        },
-      } as ApiResponse<{ user?: unknown }>
-    })
-
-    const apiClient = createMockApiClient({ loginStatus: loginStatusMock })
-    const clock = createClock()
-    const result = await pollLoginStatus(
-      {
-        sleep: clock.sleep,
-        logger,
-        now: clock.now,
-        apiClient,
-      },
-      {
-        baseUrl: 'https://cli.test',
-        fingerprintId: 'finger-network',
-        fingerprintHash: 'hash-network',
-        expiresAt: '2030-01-01T00:00:00Z',
-        intervalMs: 5,
-        timeoutMs: 100,
-      },
-    )
-
-    expect(result.status).toBe('success')
-    if (result.status !== 'success') {
-      throw new Error(`Expected polling success but received ${result.status}`)
-    }
-    expect(loginStatusMock.mock.calls.length).toBeGreaterThan(1)
-    const errorCalls = logger.error.mock.calls as Array<
-      Parameters<Logger['error']>
-    >
-    const sawNetworkFailure = errorCalls.some(([payload]) => {
-      if (!payload || typeof payload !== 'object') {
-        return false
-      }
-      return JSON.stringify(payload as Parameters<Logger['error']>[0]).includes('network failed')
-    })
-    expect(sawNetworkFailure).toBe(true)
-  })
-
-  test('P0: generateLoginUrl wrapper - should hit backend and return payload', async () => {
-    const logger = createMockLogger()
-    const payload: LoginUrlResponse = {
-      loginUrl: 'https://cli.test/login?code=code-123',
-      fingerprintHash: 'hash-123',
-      expiresAt: '2025-12-31T23:59:59Z',
-    }
-    const loginCodeMock = mock(async (req: { fingerprintId: string }) => {
-      expect(req.fingerprintId).toBe('finger-login')
-      return {
-        ok: true,
-        status: 200,
-        data: payload,
-      } as ApiResponse<LoginUrlResponse>
-    })
-
-    const apiClient = createMockApiClient({ loginCode: loginCodeMock })
-
-    const result = await generateLoginUrl(
-      { logger, apiClient },
-      { baseUrl: 'https://cli.test', fingerprintId: 'finger-login' },
-    )
-
-    expect(result).toEqual(payload)
-  })
-
-  test('P0: generateLoginUrl wrapper - should throw when backend returns error', async () => {
-    const logger = createMockLogger()
-    const loginCodeMock = mock(async () => {
-      return {
-        ok: false,
-        status: 500,
-        error: 'Server Error',
-      } as ApiResponse<LoginUrlResponse>
-    })
-
-    const apiClient = createMockApiClient({ loginCode: loginCodeMock })
-
-    await expect(
-      generateLoginUrl(
-        { logger, apiClient },
-        { baseUrl: 'https://cli.test', fingerprintId: 'finger-login' },
-      ),
-    ).rejects.toThrow('Failed to get login URL')
-  })
-})

package/src/__tests__/integration/queue-editing.test.tsx

@@ -1,261 +0,0 @@
-import { afterEach, beforeAll, beforeEach, describe, expect, test } from 'bun:test'
-import { createTestRenderer } from '@opentui/core/testing'
-import { createRoot, flushSync } from '@opentui/react'
-import React from 'react'
-
-import { ChatInputBar } from '../../components/chat-input-bar'
-import { QueuePanel } from '../../components/queue-panel'
-import { useChatKeyboard } from '../../hooks/use-chat-keyboard'
-import { useMessageQueue } from '../../hooks/use-message-queue'
-import { useQueueUi } from '../../hooks/use-queue-ui'
-import { initializeThemeStore, useTheme } from '../../hooks/use-theme'
-import { useQueuePanelStore } from '../../state/queue-panel-store'
-import { createDefaultChatKeyboardState } from '../../utils/keyboard-actions'
-
-import type { ChatKeyboardHandlers } from '../../hooks/use-chat-keyboard'
-
-let cleanupRenderer: (() => void) | undefined
-
-beforeAll(() => {
-  initializeThemeStore()
-})
-
-beforeEach(() => {
-  useQueuePanelStore.getState().closeQueuePanel()
-})
-
-afterEach(() => {
-  cleanupRenderer?.()
-  cleanupRenderer = undefined
-  useQueuePanelStore.getState().closeQueuePanel()
-})
-
-const noopHandlers = (): ChatKeyboardHandlers =>
-  new Proxy({} as ChatKeyboardHandlers, {
-    get: () => () => {},
-  })
-
-/**
- * Composes the chain chat.tsx wires up — keypress → resolver → handler →
- * panel store → panel → queue ops — without dragging in auth, the SDK, and the
- * rest of the Chat surface. It is the seam a mis-wire would hide in.
- */
-const mountChatQueue = async ({
-  queued,
-  renderQueuePreview = false,
-}: {
-  queued: string[]
-  renderQueuePreview?: boolean
-}) => {
-  const state = { submitted: [] as string[] }
-
-  const Harness = () => {
-    const theme = useTheme()
-    const inputRef = React.useRef(null)
-    const queue = useMessageQueue(
-      // Hold the queue: a real run is in flight, which is the only time
-      // messages pile up in the first place.
-      () => Promise.resolve(),
-      { current: true },
-      { current: 0 },
-    )
-    const queuePanelOpen = useQueuePanelStore((s) => s.queuePanelOpen)
-    const closeQueuePanel = useQueuePanelStore((s) => s.closeQueuePanel)
-    const { inputBoxTitle, inputPlaceholder } = useQueueUi({
-      queuePaused: false,
-      queuedMessages: queue.queuedMessages,
-      separatorWidth: 70,
-      terminalWidth: 70,
-    })
-
-    // Seed once, the way routeUserPrompt does while a run is streaming.
-    const seeded = React.useRef(false)
-    if (!seeded.current) {
-      seeded.current = true
-      queued.forEach((content) => queue.addToQueue(content))
-    }
-
-    state.submitted = queue.queuedMessages.map((m) => m.content)
-
-    useChatKeyboard({
-      state: {
-        ...createDefaultChatKeyboardState(),
-        queuedCount: queue.queuedMessages.length,
-      },
-      handlers: {
-        ...noopHandlers(),
-        onOpenQueuePanel: () =>
-          useQueuePanelStore.getState().openQueuePanel(),
-      },
-      // chat.tsx hands the keyboard to the panel while it is open.
-      disabled: queuePanelOpen,
-    })
-
-    if (!queuePanelOpen) {
-      if (!renderQueuePreview) return <text>composer</text>
-
-      return (
-        <ChatInputBar
-          inputValue=""
-          cursorPosition={0}
-          setInputValue={() => {}}
-          inputFocused
-          inputRef={inputRef}
-          inputPlaceholder={inputPlaceholder}
-          lastEditDueToNav={false}
-          agentMode="DEFAULT"
-          toggleAgentMode={() => {}}
-          setAgentMode={() => {}}
-          hasSlashSuggestions={false}
-          hasMentionSuggestions={false}
-          hasSuggestionMenu={false}
-          slashSuggestionItems={[]}
-          agentSuggestionItems={[]}
-          fileSuggestionItems={[]}
-          slashSelectedIndex={0}
-          agentSelectedIndex={0}
-          theme={theme}
-          terminalHeight={14}
-          separatorWidth={70}
-          shouldCenterInputVertically={false}
-          inputBoxTitle={inputBoxTitle}
-          onQueuePreviewClick={() =>
-            useQueuePanelStore.getState().openQueuePanel()
-          }
-          isCompactHeight={false}
-          isNarrowWidth
-          feedbackMode={false}
-          handleExitFeedback={() => {}}
-          publishMode={false}
-          handleExitPublish={() => {}}
-          handlePublish={async () => {}}
-          handleSubmit={async () => {}}
-          onPaste={() => {}}
-          onInterruptStream={() => {}}
-        />
-      )
-    }
-
-    return (
-      <QueuePanel
-        queuedMessages={queue.queuedMessages}
-        onEdit={queue.editQueuedMessage}
-        onDelete={queue.removeQueuedMessage}
-        onMove={queue.moveQueuedMessage}
-        onClose={closeQueuePanel}
-        width={70}
-      />
-    )
-  }
-
-  const setup = await createTestRenderer({
-    width: 70,
-    height: 14,
-    kittyKeyboard: true,
-  })
-  const root = createRoot(setup.renderer)
-  cleanupRenderer = () => {
-    flushSync(() => root.unmount())
-    setup.renderer.destroy()
-  }
-
-  flushSync(() => root.render(<Harness />))
-  await setup.renderOnce()
-
-  const settle = async () => {
-    await setup.renderOnce()
-    await new Promise((resolve) => setTimeout(resolve, 20))
-    await setup.renderOnce()
-  }
-  await settle()
-
-  return Object.assign(setup, {
-    queued: () => state.submitted,
-    async press(act: () => void) {
-      act()
-      await settle()
-    },
-    async click(x: number, y: number) {
-      await setup.mockMouse.click(x, y)
-      await settle()
-    },
-  })
-}
-
-const ctrlQ = (panel: { mockInput: { pressKey: Function } }) =>
-  panel.mockInput.pressKey('q', { ctrl: true })
-
-describe('editing the queue from chat', () => {
-  test('clicking the queue preview opens it and edits the clicked queued item', async () => {
-    const panel = await mountChatQueue({
-      queued: ['fix the login bug', 'add parser tests', 'update the docs'],
-      renderQueuePreview: true,
-    })
-
-    expect(panel.captureCharFrame()).toContain('update the docs (+ 2)')
-    await panel.click(35, 0)
-    expect(panel.captureCharFrame()).toContain('Queue — 3 messages')
-
-    // The border is row 0, so clicking row 2 targets the second message.
-    await panel.click(10, 2)
-    expect(panel.captureCharFrame()).toContain('❯ 2. editing')
-    expect(panel.captureCharFrame()).toContain('add parser tests')
-
-    await panel.press(() => void panel.mockInput.typeText(' now'))
-    await panel.press(() => panel.mockInput.pressEnter())
-
-    expect(panel.queued()).toEqual([
-      'fix the login bug',
-      'add parser tests now',
-      'update the docs',
-    ])
-  })
-
-  test('ctrl+q opens the editor over the composer and edits the real queue', async () => {
-    const panel = await mountChatQueue({
-      queued: ['fix the login bug', 'add parser tests'],
-    })
-    expect(panel.captureCharFrame()).toContain('composer')
-
-    await panel.press(() => ctrlQ(panel))
-    expect(panel.captureCharFrame()).toContain('Queue — 2 messages')
-
-    // Reorder, then delete what is now second — against the real queue hook.
-    await panel.press(() => panel.mockInput.pressArrow('down'))
-    await panel.press(() => panel.mockInput.pressKey('t'))
-    expect(panel.queued()).toEqual(['add parser tests', 'fix the login bug'])
-
-    await panel.press(() => panel.mockInput.pressArrow('down'))
-    await panel.press(() => panel.mockInput.pressKey('d'))
-    expect(panel.queued()).toEqual(['add parser tests'])
-  })
-
-  test('ctrl+q closes it again and the composer comes back', async () => {
-    const panel = await mountChatQueue({ queued: ['fix the login bug'] })
-
-    await panel.press(() => ctrlQ(panel))
-    expect(panel.captureCharFrame()).toContain('Queue — 1 message')
-
-    await panel.press(() => ctrlQ(panel))
-    expect(panel.captureCharFrame()).toContain('composer')
-  })
-
-  test('ctrl+q does nothing with an empty queue', async () => {
-    const panel = await mountChatQueue({ queued: [] })
-
-    await panel.press(() => ctrlQ(panel))
-
-    expect(panel.captureCharFrame()).toContain('composer')
-    expect(useQueuePanelStore.getState().queuePanelOpen).toBe(false)
-  })
-
-  test('emptying the queue from the editor hands the composer back', async () => {
-    const panel = await mountChatQueue({ queued: ['only one'] })
-
-    await panel.press(() => ctrlQ(panel))
-    await panel.press(() => panel.mockInput.pressKey('d'))
-
-    expect(panel.queued()).toEqual([])
-    expect(panel.captureCharFrame()).toContain('composer')
-  })
-})