Sync public snapshot from freebuff-private

Source: CodebuffAI/freebuff-private@234f52a231ef5a53806c00b5a95ec4bdd8422bfa

Author: github-actions[bot]

bun.lock

@@ -293,7 +293,12 @@ interface AuthedSurfaceProps {
  * we have a token).
  */
 const AuthedSurface = (props: AuthedSurfaceProps) => {
-  const { session, failure: sessionFailure } = useFreebuffSession()
+  const {
+    session,
+    failure: sessionFailure,
+    lastRefund,
+    refundPending,
+  } = useFreebuffSession()
 
   return (
     <ChatRuntimeProvider
@@ -307,6 +312,8 @@ const AuthedSurface = (props: AuthedSurfaceProps) => {
         {...props}
         session={session}
         sessionFailure={sessionFailure}
+        lastRefund={lastRefund}
+        refundPending={refundPending}
       />
     </ChatRuntimeProvider>
   )
@@ -329,9 +336,13 @@ const AuthedSurfaceRoutes = ({
   onNewChat,
   session,
   sessionFailure,
+  lastRefund,
+  refundPending,
 }: AuthedSurfaceProps & {
   session: ReturnType<typeof useFreebuffSession>['session']
   sessionFailure: ReturnType<typeof useFreebuffSession>['failure']
+  lastRefund: ReturnType<typeof useFreebuffSession>['lastRefund']
+  refundPending: boolean
 }) => {
   // Terminal state: a 409 from the gate means another CLI rotated our
   // instance id. Show a dedicated screen and stop polling — don't fall back
@@ -364,7 +375,14 @@ const AuthedSurfaceRoutes = ({
       session.status === 'ip_capped' ||
       session.status === 'takeover_prompt')
   ) {
-    return <FreebuffLandingScreen session={session} failure={sessionFailure} />
+    return (
+      <FreebuffLandingScreen
+        session={session}
+        failure={sessionFailure}
+        lastRefund={lastRefund}
+        refundPending={refundPending}
+      />
+    )
   }
 
   // Chat history renders inside AuthedSurface so the freebuff session stays

cli/src/app.tsx

@@ -67,6 +67,8 @@ import type { KeyEvent } from '@opentui/core'
 interface FreebuffLandingScreenProps {
   session: FreebuffSessionResponse | null
   failure: FreebuffSessionFailure | null
+  lastRefund: number | null
+  refundPending: boolean
 }
 
 /** Landing-screen heading. Referenced both as rendered text and by the
@@ -354,6 +356,8 @@ export const LandingHeadingRow: React.FC<{
 export const FreebuffLandingScreen: React.FC<FreebuffLandingScreenProps> = ({
   session,
   failure,
+  lastRefund,
+  refundPending,
 }) => {
   const theme = useTheme()
   const renderer = useRenderer()
@@ -679,6 +683,19 @@ export const FreebuffLandingScreen: React.FC<FreebuffLandingScreenProps> = ({
             </text>
           )}
 
+          {refundPending && (
+            <text style={{ fg: theme.secondary, wrapMode: 'word' }}>
+              Your refund is awaiting final usage. Once settled, it will appear
+              in your wallet.
+            </text>
+          )}
+          {lastRefund !== null && (
+            <text style={{ fg: theme.secondary, wrapMode: 'word' }}>
+              {lastRefund} {lastRefund === 1 ? 'Freebuck' : FREEBUCKS_LABEL}{' '}
+              returned to your wallet.
+            </text>
+          )}
+
           {!session && !failure && (
             <text style={{ fg: theme.muted }}>
               <ShimmerText text="Connecting…" />

cli/src/components/freebuff-landing-screen.tsx

@@ -195,7 +195,7 @@ const ALL_SLASH_COMMANDS: SlashCommand[] = [
   {
     id: 'end-session',
     label: 'end-session',
-    description: 'End your free session (lets you switch model)',
+    description: 'End session; get 90% of unspent cost back, rounded down',
     aliases: ['model'],
   },
   {

cli/src/data/slash-commands.ts

@@ -0,0 +1,86 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from 'bun:test'
+
+import { useChatStore } from '../../state/chat-store'
+import { useFreebuffSessionStore } from '../../state/freebuff-session-store'
+import * as auth from '../../utils/auth'
+import { IS_FREEBUFF } from '../../utils/constants'
+import { getUserMessage } from '../../utils/message-history'
+import { returnToFreebuffLanding } from '../use-freebuff-session'
+
+// Exercise the command's real transition in Freebuff mode:
+// FREEBUFF_MODE=true bun test src/hooks/__tests__/end-freebuff-session.test.ts
+// The React poll controller is absent; the transition still owns release/reset.
+describe.skipIf(!IS_FREEBUFF)('end-session transition', () => {
+  let authSpy: ReturnType<typeof spyOn>
+  let fetchSpy: ReturnType<typeof spyOn>
+  const session = {
+    status: 'active' as const,
+    accessTier: 'full' as const,
+    instanceId: 'held-cli',
+    model: 'mimo/mimo-v2.5',
+    admittedAt: '2099-09-07T12:00:00Z',
+    expiresAt: '2099-09-07T13:00:00Z',
+    remainingMs: 300000,
+  }
+  beforeEach(() => {
+    authSpy = spyOn(auth, 'getAuthTokenDetails').mockReturnValue({
+      token: 'test-token',
+      source: 'environment',
+    })
+    fetchSpy = spyOn(globalThis, 'fetch').mockRejectedValue(
+      new Error('offline'),
+    )
+    useFreebuffSessionStore.getState().setSession(session)
+    useChatStore.getState().setMessages([getUserMessage('Keep my work')])
+  })
+  afterEach(() => {
+    authSpy.mockRestore()
+    fetchSpy.mockRestore()
+    useFreebuffSessionStore.getState().setSession(null)
+    useFreebuffSessionStore.getState().setFailure(null)
+    useChatStore.getState().reset()
+  })
+
+  test('failed end preserves history and identity, explains retry, then resets on confirmation', async () => {
+    const original = useChatStore.getState().messages[0]
+    await expect(returnToFreebuffLanding({ resetChat: true })).rejects.toThrow(
+      'offline',
+    )
+    expect(useChatStore.getState().messages[0]).toEqual(original)
+    expect(JSON.stringify(useChatStore.getState().messages)).toContain(
+      'Retry /end-session',
+    )
+    expect(useFreebuffSessionStore.getState().session).toEqual(session)
+    fetchSpy.mockResolvedValue(
+      Response.json({ status: 'ended', freebucksRefund: 4 }),
+    )
+    await returnToFreebuffLanding({ resetChat: true })
+    expect(useChatStore.getState().messages).toHaveLength(0)
+    expect(useFreebuffSessionStore.getState().lastRefund).toBe(4)
+    for (const [, init] of fetchSpy.mock.calls) {
+      expect(new Headers(init.headers).get('x-freebuff-instance-id')).toBe(
+        'held-cli',
+      )
+    }
+  })
+
+  test('an old end cannot reset a replacement chat', async () => {
+    let respond!: (response: Response) => void
+    fetchSpy.mockImplementation(
+      () =>
+        new Promise<Response>((resolve) => {
+          respond = resolve
+        }),
+    )
+    const ending = returnToFreebuffLanding({ resetChat: true })
+    useFreebuffSessionStore
+      .getState()
+      .setSession({ ...session, instanceId: 'new-cli' })
+    const replacement = getUserMessage('New work')
+    useChatStore.getState().setMessages([replacement])
+    respond(Response.json({ status: 'ended', freebucksRefund: 4 }))
+    await ending
+    expect(useChatStore.getState().messages).toEqual([replacement])
+    expect(useFreebuffSessionStore.getState().lastRefund).toBeNull()
+  })
+})

cli/src/hooks/__tests__/end-freebuff-session.test.ts

@@ -42,7 +42,6 @@ import {
   holdsLiveFreebuffSlot,
   isFreebuffSessionTimeoutError,
   mergeCompactActiveSession,
-  releaseFreebuffSlot,
 } from '../utils/freebuff-session-api'
 import {
   failedPollDelayMs,
@@ -212,16 +211,42 @@ async function restartFreebuffSession(
   // resetting its store so late deltas cannot land in the next session.
   if (opts.resetChat) {
     stopActiveRun('session-transition')
-    useChatStore.getState().reset()
   }
   // Halt the running poll loop before we touch local stores or DELETE the
   // slot. Otherwise an in-flight GET could land mid-reset and overwrite
   // state, or the next scheduled tick could fire between DELETE and
   // restart() with stale assumptions. restart() re-aborts and re-arms
   // below; the extra abort here is cheap.
-  controller?.abort()
-  if (opts.releaseSlot) await releaseFreebuffSlot()
-  await controller?.restart(mode)
+  const currentController = controller
+  const currentToken = getAuthTokenDetails().token
+  const currentSession = useFreebuffSessionStore.getState().session
+  const stillCurrent = () =>
+    controller === currentController &&
+    getAuthTokenDetails().token === currentToken &&
+    useFreebuffSessionStore.getState().session === currentSession
+  currentController?.abort()
+  if (opts.releaseSlot) {
+    try {
+      await useFreebuffSessionStore.getState()
+    .releaseSlot()
+    } catch (error) {
+      if (!stillCurrent()) throw error
+      // Keep the chat and held instance: the server may already have credited
+      // the refund. A retry must use that same instance to recover its receipt.
+      useChatStore
+        .getState()
+        .setMessages((messages) => [
+          ...messages,
+          getSystemMessage(
+            `Could not confirm the session ended. Retry /end-session. ${error instanceof Error ? error.message : String(error)}`,
+          ),
+        ])
+      throw error
+    }
+  }
+  if (!stillCurrent()) return
+  if (opts.resetChat) useChatStore.getState().reset()
+  await currentController?.restart(mode)
 }
 
 /**
@@ -356,7 +381,9 @@ export function markFreebuffSessionCountryBlocked(params: {
   controller?.apply({ status: 'country_blocked', ...params })
   // Best-effort DELETE so we don't hold a session row the server is already
   // refusing to serve at chat time.
-  releaseFreebuffSlot().catch(() => {})
+  useFreebuffSessionStore
+    .getState().releaseSlot()
+    .catch(() => {})
 }
 
 /** Flip into the local `ended` state without an instanceId (server has lost
@@ -382,6 +409,8 @@ export function markFreebuffSessionEnded(): void {
 interface UseFreebuffSessionResult {
   session: FreebuffSessionResponse | null
   failure: ReturnType<typeof useFreebuffSessionStore.getState>['failure']
+  lastRefund: number | null
+  refundPending: boolean
 }
 
 /**
@@ -400,6 +429,26 @@ interface UseFreebuffSessionResult {
 export function useFreebuffSession(): UseFreebuffSessionResult {
   const session = useFreebuffSessionStore((s) => s.session)
   const failure = useFreebuffSessionStore((s) => s.failure)
+  const lastRefund = useFreebuffSessionStore((s) => s.lastRefund)
+  const pendingRefund = useFreebuffSessionStore((s) => s.pendingRefund)
+  useEffect(() => {
+    if (!pendingRefund) return
+    let cancelled = false
+    let timer: ReturnType<typeof setTimeout>
+    const poll = async () => {
+      try {
+        await useFreebuffSessionStore.getState().refreshRefund()
+      } catch {
+        /* Keep the pending receipt for a later retry. */
+      }
+      if (!cancelled) timer = setTimeout(poll, 3000)
+    }
+    timer = setTimeout(poll, 3000)
+    return () => {
+      cancelled = true
+      clearTimeout(timer)
+    }
+  }, [pendingRefund])
 
   useEffect(() => {
     const { setSession, setFailure } = useFreebuffSessionStore.getState()
@@ -525,7 +574,7 @@ export function useFreebuffSession(): UseFreebuffSessionResult {
         // another model rejects the switch. Two cases:
         //   - DELIBERATE pick (the explicit-pick marker was set): honor the
         //     click — end the locked session (usually a stale row from a
-        //     crashed CLI; DELETE is keyed on user, not instance) and
+        //     crashed CLI; read its instance before deleting) and
         //     re-claim on the requested model. The marker is consume-once,
         //     so if the retried POST races another instance back into
         //     model_locked we take the revert branch instead of looping.
@@ -541,10 +590,21 @@ export function useFreebuffSession(): UseFreebuffSessionResult {
             const requested = getFreebuffModel(explicitPickModel).displayName
             let released = false
             try {
-              await callFreebuffSession('DELETE', token, {
+              const held = await callFreebuffSession('GET', token, {
                 signal: fetchController.signal,
               })
-              released = true
+              if (
+                !cancelled &&
+                !fetchController.signal.aborted &&
+                generation === restartGeneration &&
+                held.status === 'active' &&
+                held.model === next.currentModel
+              ) {
+                await useFreebuffSessionStore
+                  .getState()
+                  .releaseSlot(held, fetchController.signal)
+                released = true
+              }
             } catch {
               // DELETE failed — fall through to the revert-with-explanation
               // path below rather than stranding the user mid-switch.
@@ -857,12 +917,15 @@ export function useFreebuffSession(): UseFreebuffSessionResult {
       // Fire-and-forget DELETE. Only release if we actually held a slot so
       // we don't generate spurious DELETEs (e.g. HMR before POST completes).
       if (holdsLiveFreebuffSlot(current)) {
-        callFreebuffSession('DELETE', token).catch(() => {})
+        useFreebuffSessionStore
+          .getState()
+          .releaseSlot()
+          .catch(() => {})
       }
       setSession(null)
       setFailure(null)
     }
   }, [])
 
-  return { session, failure }
+  return { session, failure, lastRefund, refundPending: pendingRefund !== null }
 }