Sync public snapshot from freebuff-private

Source: CodebuffAI/freebuff-private@7efb0a7c27f171e704f1d43c0488f905b0d6c7d1

Author: github-actions[bot]

bun.lock

@@ -0,0 +1,127 @@
+import fs from 'fs'
+import os from 'os'
+import path from 'path'
+
+import { freebucksFixture } from '@codebuff/common/testing/freebuff'
+import {
+  FREEBUFF_GLM_V53_FLASH_MODEL_ID,
+  FALLBACK_FREEBUFF_MODEL_ID,
+} from '@codebuff/common/constants/freebuff-models'
+import { afterEach, beforeAll, expect, spyOn, test } from 'bun:test'
+import { createTestRenderer } from '@opentui/core/testing'
+import { createRoot, flushSync } from '@opentui/react'
+import React from 'react'
+
+import * as auth from '../../utils/auth'
+import { FreebucksIntroCard, useFreebucksIntro } from '../freebucks-intro-card'
+import { FreebuffModelSelector } from '../freebuff-model-selector'
+import { initializeThemeStore } from '../../hooks/use-theme'
+import { useFreebuffModelStore } from '../../state/freebuff-model-store'
+import { useFreebuffSessionStore } from '../../state/freebuff-session-store'
+
+/** Outside DeepSeek's expensive window and inside deployment hours, so every
+ *  catalog row is open regardless of the hour CI runs at. */
+const FIXED_NOW_MS = Date.UTC(2026, 7, 20, 19, 0, 0)
+
+let cleanupRenderer: (() => void) | undefined
+let testConfigDir: string | undefined
+let getConfigDirSpy: ReturnType<typeof spyOn> | undefined
+
+beforeAll(() => {
+  initializeThemeStore()
+})
+
+afterEach(() => {
+  cleanupRenderer?.()
+  cleanupRenderer = undefined
+  getConfigDirSpy?.mockRestore()
+  getConfigDirSpy = undefined
+  if (testConfigDir) {
+    fs.rmSync(testConfigDir, { recursive: true, force: true })
+    testConfigDir = undefined
+  }
+  useFreebuffSessionStore.getState().setSession(null)
+  useFreebuffModelStore.getState().setSelectedModel(FALLBACK_FREEBUFF_MODEL_ID)
+})
+
+/** The landing screen's arrangement, reduced to the two pieces that share the
+ *  keyboard: the intro card above and the picker below. */
+const Landing = ({
+  startSession,
+}: {
+  startSession: (model: string) => Promise<void>
+}) => {
+  const intro = useFreebucksIntro(true)
+  return (
+    <box style={{ flexDirection: 'column' }}>
+      {intro.visible && (
+        <FreebucksIntroCard width={72} onDismiss={intro.dismiss} />
+      )}
+      <FreebuffModelSelector
+        maxHeight={40}
+        nowMs={FIXED_NOW_MS}
+        keyboardSuspended={intro.visible}
+        startSession={startSession}
+      />
+    </box>
+  )
+}
+
+const renderLanding = async (startSession: (model: string) => Promise<void>) => {
+  testConfigDir = fs.mkdtempSync(path.join(os.tmpdir(), 'freebucks-intro-'))
+  getConfigDirSpy = spyOn(auth, 'getConfigDir').mockReturnValue(testConfigDir)
+  useFreebuffSessionStore.getState().setSession({
+    status: 'none',
+    accessTier: 'full',
+    freebucks: freebucksFixture(75),
+  } as never)
+  useFreebuffModelStore
+    .getState()
+    .setSelectedModel(FREEBUFF_GLM_V53_FLASH_MODEL_ID)
+
+  const setup = await createTestRenderer({ width: 100, height: 40 })
+  const root = createRoot(setup.renderer)
+  cleanupRenderer = () => {
+    flushSync(() => root.unmount())
+    setup.renderer.destroy()
+  }
+  flushSync(() => root.render(<Landing startSession={startSession} />))
+  await setup.renderOnce()
+  return setup
+}
+
+// The bug this file exists for: the card's "press any key to continue" and the
+// picker's "Enter starts a session" were two independent keyboard
+// subscriptions, so the dismissal press ALSO committed the focused row — the
+// cheapest one, since a metered list is sorted by price. Users reported it as
+// "it started a GLM 5.3 session I didn't want to start" (2026-09-08).
+test('dismissing the Freebucks intro does not start a session', async () => {
+  const requested: string[] = []
+  const setup = await renderLanding(async (model) => {
+    requested.push(model)
+  })
+  expect(setup.captureCharFrame()).toContain('Meet Freebucks')
+
+  flushSync(() => setup.mockInput.pressEnter())
+  await setup.renderOnce()
+
+  expect(requested).toEqual([])
+  expect(setup.captureCharFrame()).not.toContain('Meet Freebucks')
+
+  // And the picker is live again the moment the card is gone: the next Enter
+  // is the one the user meant for it.
+  flushSync(() => setup.mockInput.pressEnter())
+  await setup.renderOnce()
+  expect(requested).toEqual([FREEBUFF_GLM_V53_FLASH_MODEL_ID])
+})
+
+test('space dismisses the intro without committing a row either', async () => {
+  const requested: string[] = []
+  const setup = await renderLanding(async (model) => {
+    requested.push(model)
+  })
+  flushSync(() => setup.mockInput.pressKey(' '))
+  await setup.renderOnce()
+  expect(requested).toEqual([])
+  expect(setup.captureCharFrame()).not.toContain('Meet Freebucks')
+})

cli/src/components/__tests__/freebucks-intro-card.test.tsx

@@ -10,6 +10,8 @@ import { createTestRenderer } from '@opentui/core/testing'
 import { createRoot, flushSync } from '@opentui/react'
 import React from 'react'
 
+import { FREEBUCKS_LABEL } from '../../utils/freebucks'
+import * as openUrl from '../../utils/open-url'
 import { FreebuffModelSelector } from '../freebuff-model-selector'
 import {
   FREEBUFF_REWARD_MODEL_ID,
@@ -918,6 +920,88 @@ test.each([
   },
 )
 
+// A row the meter cannot cover used to be inert in both directions: the Enter
+// handler and the click handler both gated on `isJoinable`, so pressing it did
+// nothing at all — no message, no plans link. On a metered account that is the
+// whole of what users reported as "I can't change models": the cheapest row
+// starts and every dearer one is silent (2026-09-08). The wall now speaks, and
+// the second press opens the page that is the only thing which changes the
+// answer.
+describe('a row the balance cannot cover', () => {
+  const renderUnaffordableLuna = async () => {
+    useFreebuffSessionStore.getState().setSession({
+      status: 'none',
+      accessTier: 'full',
+      freebucks: freebucksFixture(10, {
+        [FREEBUFF_GPT_5_6_LUNA_MODEL_ID]: 20,
+        [FREEBUFF_MIMO_V25_MODEL_ID]: 10,
+      }),
+    })
+    useFreebuffModelStore
+      .getState()
+      .setSelectedModel(FREEBUFF_MIMO_V25_MODEL_ID)
+    const requested: string[] = []
+    const setup = await renderSelector(40, async (model) => {
+      requested.push(model)
+    })
+    await setup.renderOnce()
+    // Walk the focus onto Luna rather than assuming where it lands.
+    for (let i = 0; i < 12; i++) {
+      if (setup.captureCharFrame().includes('› GPT-5.6 Luna')) break
+      flushSync(() => setup.mockInput.pressKey('ARROW_DOWN'))
+      await setup.renderOnce()
+    }
+    expect(setup.captureCharFrame()).toContain('› GPT-5.6 Luna')
+    return { setup, requested }
+  }
+
+  test('explains the wall on the first press instead of doing nothing', async () => {
+    const { setup, requested } = await renderUnaffordableLuna()
+    flushSync(() => setup.mockInput.pressEnter())
+    await setup.renderOnce()
+    const frame = setup.captureCharFrame()
+    expect(frame).toContain(`Not enough ${FREEBUCKS_LABEL}`)
+    expect(frame).toContain('Enter opens plans')
+    expect(requested).toEqual([])
+  })
+
+  test('opens the plans page on the second press, and starts nothing', async () => {
+    const openSpy = spyOn(openUrl, 'safeOpen').mockResolvedValue(true)
+    try {
+      const { setup, requested } = await renderUnaffordableLuna()
+      flushSync(() => setup.mockInput.pressEnter())
+      await setup.renderOnce()
+      flushSync(() => setup.mockInput.pressEnter())
+      await setup.renderOnce()
+      expect(openSpy).toHaveBeenCalledWith('https://freebuff.com/plans')
+      expect(requested).toEqual([])
+      expect(getSelectedFreebuffModel()).toBe(FREEBUFF_MIMO_V25_MODEL_ID)
+    } finally {
+      openSpy.mockRestore()
+    }
+  })
+
+  test('a row closed for the hour stays inert — no wall to raise', async () => {
+    useFreebuffSessionStore.getState().setSession({
+      status: 'none',
+      accessTier: 'full',
+      freebucks: freebucksFixture(10, {
+        [FREEBUFF_GPT_5_6_LUNA_MODEL_ID]: 20,
+      }),
+    })
+    useFreebuffModelStore
+      .getState()
+      .setSelectedModel(FREEBUFF_MIMO_V25_MODEL_ID)
+    const setup = await renderSelector()
+    await setup.renderOnce()
+    // Nothing is asking anything before a press; the assertion above is what
+    // makes the two cases distinguishable at all.
+    expect(setup.captureCharFrame()).not.toContain(
+      `Not enough ${FREEBUCKS_LABEL}`,
+    )
+  })
+})
+
 test.each([false, true])(
   'Freebucks does not change Luna plan access (paid=%s)',
   async (paid) => {

cli/src/components/__tests__/freebuff-model-selector.test.tsx

@@ -1,42 +1,74 @@
 import { TextAttributes } from '@opentui/core'
 import { useKeyboard } from '@opentui/react'
-import { useEffect, useState } from 'react'
+import { useCallback, useEffect, useState } from 'react'
 
 import { FREEBUCKS_INTRO } from '../utils/freebucks'
 import { hasSeenFreebucksIntro, markFreebucksIntroSeen } from '../utils/settings'
 import { useTheme } from '../hooks/use-theme'
 
 /**
- * The one-time introduction to Freebucks, above the picker on the landing.
+ * Whether the one-time Freebucks introduction is on screen, and how to retire it.
  *
  * Shown the FIRST launch on which the account is METERED — the caller passes
  * `metered`, read off the session's `freebucks` block like every other
- * surface — and never again. The seen mark is written the moment this
- * RENDERS, not on dismissal: a launch that ends before the user presses
- * anything must not be shown it twice. It is a card and not a modal because
- * the CLI landing has no modal layer and the picker below it keeps working;
- * any key the picker handles also retires the card for this launch.
+ * surface — and never again. The seen mark is written the moment it becomes
+ * visible, not on dismissal: a launch that ends before the user presses
+ * anything must not be shown it twice.
+ *
+ * THE VISIBILITY LIVES IN THE PARENT, not inside the card, because the picker
+ * below has to know about it. The card says "press any key to continue" and
+ * the picker commits its focused row on Enter or Space; the two are
+ * independent `useKeyboard` subscriptions, so the dismissal key ALSO started a
+ * session on whichever row the cursor happened to be on — the cheapest one,
+ * since a metered list is sorted by price. A charge the user never asked for,
+ * on a model they did not choose, and the most reported Freebucks bug
+ * (2026-09-08).
+ *
+ * The landing screen suspends the picker's keyboard while this is true, and
+ * the card stops the dismissal key propagating. EITHER guard alone would fix
+ * it, and neither is enough on its own to rely on: which handler runs first is
+ * an artifact of effect registration order (children before parents, siblings
+ * in tree order), which no one should have to reason about to know whether a
+ * keypress spends money.
+ */
+export function useFreebucksIntro(metered: boolean): {
+  visible: boolean
+  dismiss: () => void
+} {
+  const [visible, setVisible] = useState<boolean>(
+    () => metered && !hasSeenFreebucksIntro(),
+  )
+  useEffect(() => {
+    if (!metered) return
+    if (hasSeenFreebucksIntro()) return
+    markFreebucksIntroSeen()
+    setVisible(true)
+  }, [metered])
+  const dismiss = useCallback(() => setVisible(false), [])
+  return { visible, dismiss }
+}
+
+/**
+ * The card itself, above the picker on the landing. Rendered only while
+ * `useFreebucksIntro` says its state is visible; it is a card and not a modal
+ * because the CLI landing has no modal layer.
+ *
+ * It owns the dismissal key and consumes it — see the hook above for why that
+ * is one of two guards rather than the only one.
  */
 export function FreebucksIntroCard({
-  metered,
   width,
+  onDismiss,
 }: {
-  metered: boolean
   width: number
+  onDismiss: () => void
 }) {
   const theme = useTheme()
-  const [show, setShow] = useState<boolean>(() => metered && !hasSeenFreebucksIntro())
-  useEffect(() => {
-    if (!metered) return
-    if (hasSeenFreebucksIntro()) return
-    markFreebucksIntroSeen()
-    setShow(true)
-  }, [metered])
-  // Any key retires it for this launch; the picker still receives the key.
-  useKeyboard(() => {
-    if (show) setShow(false)
+  useKeyboard((key) => {
+    key.stopPropagation?.()
+    key.preventDefault?.()
+    onDismiss()
   })
-  if (!show) return null
   return (
     <box
       style={{

cli/src/components/freebucks-intro-card.tsx

@@ -13,7 +13,7 @@ import {
 import { Button } from './button'
 import { ChoiceAdBanner, AD_CARD_HEIGHT } from './ad-banner'
 import { visibleWaitingRoomPlacementIds } from '@codebuff/common/ads/waiting-room-placements'
-import { FreebucksIntroCard } from './freebucks-intro-card'
+import { FreebucksIntroCard, useFreebucksIntro } from './freebucks-intro-card'
 import { FreebuffModelSelector } from './freebuff-model-selector'
 import { ShimmerText } from './shimmer-text'
 import {
@@ -460,6 +460,16 @@ export const FreebuffLandingScreen: React.FC<FreebuffLandingScreenProps> = ({
   // state: show the picker with a prompt. Picking a model triggers
   // startFreebuffSession, which POSTs and transitions straight to 'active' (chat).
   const isLanding = session?.status === 'none'
+  // The one-time Freebucks introduction, only where the picker itself is on
+  // screen and only where it fits: on a short terminal it would push the
+  // picker off the bottom, and an unseen card is shown on the next launch
+  // instead (it is marked seen only when it becomes visible, so a launch that
+  // lands on a wall instead of the picker must not consume it). Held here
+  // rather than inside the card so the picker below can be told to ignore the
+  // key that dismisses it — see `useFreebucksIntro`.
+  const freebucksIntro = useFreebucksIntro(
+    isLanding && terminalHeight >= 30 && freebucksOf(session) !== undefined,
+  )
   // On the meter, nothing below counts sessions.
   const metered = freebucksOf(session) !== undefined
   const streakQuery = useFreebuffStreakQuery({
@@ -710,14 +720,10 @@ export const FreebuffLandingScreen: React.FC<FreebuffLandingScreenProps> = ({
                 gap: 0,
               }}
             >
-              {/* The one-time Freebucks introduction, only where it fits:
-                  on a short terminal it would push the picker off the
-                  bottom, and an unseen card is shown on the next launch
-                  instead (it is marked seen only when it renders). */}
-              {terminalHeight >= 30 && (
+              {freebucksIntro.visible && (
                 <FreebucksIntroCard
-                  metered={freebucksOf(session) !== undefined}
                   width={Math.min(contentMaxWidth, 72)}
+                  onDismiss={freebucksIntro.dismiss}
                 />
               )}
               <LandingHeadingRow
@@ -730,6 +736,9 @@ export const FreebuffLandingScreen: React.FC<FreebuffLandingScreenProps> = ({
               <FreebuffModelSelector
                 maxHeight={selectorMaxHeight}
                 onExpandedChange={setSelectorExpanded}
+                // The intro card owns the keyboard while it is up: its "press
+                // any key" must not also commit the focused row.
+                keyboardSuspended={freebucksIntro.visible}
                 belowToggle={
                   showBelowPickerCounter ? (
                     <text