Sync public snapshot from freebuff-private

Source: CodebuffAI/freebuff-private@5e536272ee4cb2fedc20afabd21a811dd5762362

Author: github-actions[bot]

bun.lock

@@ -6,7 +6,13 @@
  * - mode "clean": start the watchdog, then stop it and exit (clean shutdown).
  *
  * Prints "ready" once the watchdog is armed so the test knows when to kill.
+ * On Windows, arming is asynchronous (a PowerShell bootstrap has to launch
+ * the real watchdog outside Bun's kill-on-close job object), so we wait for
+ * the `<ttyPath>.armed` marker before printing "ready" — killing earlier
+ * would take the bootstrap down before the watchdog exists.
  */
+import { existsSync } from 'fs'
+
 import {
   startTerminalWatchdog,
   stopTerminalWatchdog,
@@ -19,13 +25,26 @@ if (!mode || !ttyPath) {
   process.exit(2)
 }
 
+async function waitForArmed(): Promise<void> {
+  if (process.platform !== 'win32') return
+  const deadline = Date.now() + 30_000
+  while (Date.now() < deadline) {
+    if (existsSync(`${ttyPath}.armed`)) return
+    await new Promise((r) => setTimeout(r, 50))
+  }
+  console.error('watchdog never armed')
+  process.exit(3)
+}
+
 startTerminalWatchdog({ ttyPath })
 
 if (mode === 'clean') {
+  await waitForArmed()
   stopTerminalWatchdog()
   console.log('ready')
   process.exit(0)
 }
 
+await waitForArmed()
 console.log('ready')
 setInterval(() => {}, 1_000)

cli/src/__tests__/helpers/terminal-watchdog-fixture.ts

@@ -31,7 +31,7 @@ function waitForReady(child: ChildProcess): Promise<void> {
       out += chunk.toString()
       if (out.includes('ready')) resolve()
     })
-    child.on('exit', () => resolve()) // "clean" mode exits immediately
+    child.on('exit', () => resolve()) // "clean" mode exits after arming
     child.on('error', reject)
   })
 }
@@ -61,9 +61,10 @@ async function pollForContent(ttyPath: string, timeoutMs: number): Promise<strin
   return readTty(ttyPath)
 }
 
-// The watchdog is POSIX-only (sh + /dev/tty); on Windows the npm wrapper is
-// the safety net instead.
-describe.skipIf(process.platform === 'win32')('terminal watchdog', () => {
+// POSIX uses a detached sh blocking on pipe EOF; Windows uses a PowerShell
+// grandchild (outside Bun's kill-on-close job object) blocking on
+// Wait-Process. Both then write the reset sequences to the injected ttyPath.
+describe('terminal watchdog', () => {
   test('writes reset sequences to the tty when the process dies uncleanly', async () => {
     const ttyPath = join(tempDir, 'unclean.out')
     const child = spawnFixture('hang', ttyPath)
@@ -72,17 +73,21 @@ describe.skipIf(process.platform === 'win32')('terminal watchdog', () => {
     child.kill('SIGKILL')
     await waitForExit(child)
 
-    const written = await pollForContent(ttyPath, 5_000)
+    // Wait-Process wakeup + write can take a few seconds under CI load.
+    const written = await pollForContent(ttyPath, 15_000)
     expect(written).toBe(TERMINAL_RESET_SEQUENCES)
-  }, 15_000)
+  }, 60_000)
 
   test('stays silent when the process shuts down cleanly', async () => {
     const ttyPath = join(tempDir, 'clean.out')
     const child = spawnFixture('clean', ttyPath)
     await waitForExit(child)
 
-    // Give a killed-too-late watchdog time to (incorrectly) fire.
-    await new Promise((r) => setTimeout(r, 500))
+    // Give a disarmed-too-late watchdog time to (incorrectly) fire. Windows
+    // gets longer since the watchdog wakes asynchronously via Wait-Process.
+    await new Promise((r) =>
+      setTimeout(r, process.platform === 'win32' ? 3_000 : 500),
+    )
     expect(readTty(ttyPath)).toBe('')
-  }, 15_000)
+  }, 60_000)
 })

cli/src/__tests__/terminal-watchdog.test.ts

@@ -2,6 +2,7 @@ import { AnalyticsEvent } from '@codebuff/common/constants/analytics-events'
 import type { FeedbackCategory } from '@codebuff/common/constants/feedback'
 import { safeOpen } from './utils/open-url'
 import {
+  Fragment,
   useCallback,
   useEffect,
   useLayoutEffect,
@@ -13,7 +14,7 @@ import { useShallow } from 'zustand/react/shallow'
 
 import { getAdsEnabled } from './commands/ads'
 import { routeUserPrompt, addBashMessageToHistory } from './commands/router'
-import { SingleAdBanner } from './components/ad-banner'
+import { InlineAdBanner } from './components/ad-banner'
 import { ChatInputBar } from './components/chat-input-bar'
 import { FreebuffActiveSessionSummary } from './components/freebuff-active-session-summary'
 import { LoadPreviousButton } from './components/load-previous-button'
@@ -190,11 +191,22 @@ export const Chat = ({
   })
   const hasSubscription = subscriptionData?.hasSubscription ?? false
 
-  const { ads, recordClick, recordImpression } = useGravityAd({
+  const { placedAds, recordClick, recordImpression } = useGravityAd({
     enabled: IS_FREEBUFF || !hasSubscription,
     provider: 'gravity',
+    inline: true,
+    surface: 'cli_chat',
   })
 
+  // Index placed ads by the message they're anchored below, so the transcript
+  // render can drop each ad in right after its anchor message.
+  const adByAnchor = useMemo(() => {
+    const map = new Map<string, (typeof placedAds)[number]>()
+    for (const placed of placedAds) map.set(placed.afterMessageId, placed)
+    return map
+  }, [placedAds])
+  const showInlineAds = IS_FREEBUFF || getAdsEnabled()
+
   // Set initial mode from CLI flag on mount
   useEffect(() => {
     if (initialMode) {
@@ -1514,14 +1526,23 @@ export const Chat = ({
         )}
         {visibleTopLevelMessages.map((message, idx) => {
           const isLast = idx === visibleTopLevelMessages.length - 1
+          const anchoredAd = adByAnchor.get(message.id)
           return (
-            <MessageWithAgents
-              key={message.id}
-              message={message}
-              depth={0}
-              isLastMessage={isLast}
-              availableWidth={messageAvailableWidth}
-            />
+            <Fragment key={message.id}>
+              <MessageWithAgents
+                message={message}
+                depth={0}
+                isLastMessage={isLast}
+                availableWidth={messageAvailableWidth}
+              />
+              {showInlineAds && anchoredAd && (
+                <InlineAdBanner
+                  ad={anchoredAd.ad}
+                  onClick={recordClick}
+                  onImpression={recordImpression}
+                />
+              )}
+            </Fragment>
           )
         })}
         {/* Pending bash messages as ghost messages (only show those not already in history) */}
@@ -1563,14 +1584,6 @@ export const Chat = ({
           />
         )}
 
-        {ads?.[0] && (IS_FREEBUFF || getAdsEnabled()) && (
-          <SingleAdBanner
-            ad={ads[0]}
-            onClick={recordClick}
-            onImpression={recordImpression}
-          />
-        )}
-
         {reviewMode ? (
           // Review and ask_user take precedence over the session-ended banner:
           // during the grace window the agent may still be asking to run tools

cli/src/chat.tsx

@@ -161,6 +161,33 @@ export const SingleAdBanner: React.FC<{
   )
 }
 
+/**
+ * A single ad embedded inside the chat transcript, anchored below a message so
+ * it stays in scrollback. Same card as {@link SingleAdBanner} but with a bottom
+ * spacer so it reads as its own block between messages; fires its impression on
+ * mount (deduped per impUrl in the hook, so scroll churn won't double-count).
+ */
+export const InlineAdBanner: React.FC<{
+  ad: AdResponse
+  onClick?: (ad: AdResponse) => void
+  onImpression?: (ad: AdResponse) => void
+}> = ({ ad, onClick, onImpression }) => {
+  const { terminalWidth } = useTerminalDimensions()
+
+  // Full width minus left/right margin of 1 each.
+  const width = terminalWidth - 2
+
+  useEffect(() => {
+    onImpression?.(ad)
+  }, [ad, onImpression])
+
+  return (
+    <box style={{ marginLeft: 1, marginRight: 1, paddingBottom: 1 }}>
+      <AdCard ad={ad} width={width} onClick={onClick} />
+    </box>
+  )
+}
+
 /**
  * Up to four ads shown in a row. Still used by the freebuff landing screen,
  * which intentionally fills the space with multiple ads.