@alumbwe/anvil 1.0.0

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

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

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

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