add cmd f

Author: icecrasher321

apps/desktop/src/main/browser-agent/session.test.ts

@@ -27,6 +27,8 @@ interface MockView {
     isDestroyed: ReturnType<typeof vi.fn>
     setBackgroundThrottling: ReturnType<typeof vi.fn>
     capturePage: ReturnType<typeof vi.fn>
+    findInPage: ReturnType<typeof vi.fn>
+    stopFindInPage: ReturnType<typeof vi.fn>
   }
   setBackgroundColor: ReturnType<typeof vi.fn>
   setBounds: ReturnType<typeof vi.fn>
@@ -116,6 +118,7 @@ describe('browser-agent session', () => {
     )
     expect(session.browserShortcutForInput({ ...input, key: 't' }, 'darwin')).toBe('new-tab')
     expect(session.browserShortcutForInput({ ...input, key: 'w' }, 'darwin')).toBe('close-tab')
+    expect(session.browserShortcutForInput({ ...input, key: 'f' }, 'darwin')).toBe('find')
     expect(
       session.browserShortcutForInput({ ...input, key: 't', shift: true }, 'darwin')
     ).toBeNull()
@@ -169,6 +172,166 @@ describe('browser-agent session', () => {
     expect(win.webContents.send).toHaveBeenLastCalledWith('browser-agent:focus-omnibox', 'clear')
   })
 
+  it('opens the renderer find bar when the page takes Mod+F', () => {
+    panel.setPanelBounds({ x: 100, y: 50, width: 800, height: 600 })
+    const tab = session.requireTab()
+    const contents = (tab.view as unknown as MockView).webContents
+    const beforeInput = contents.on.mock.calls.find(
+      ([eventName]) => eventName === 'before-input-event'
+    )?.[1] as
+      | ((event: { preventDefault: () => void }, input: Record<string, unknown>) => void)
+      | undefined
+    const event = { preventDefault: vi.fn() }
+
+    beforeInput?.(event, {
+      type: 'keyDown',
+      key: 'f',
+      isAutoRepeat: false,
+      isComposing: false,
+      shift: false,
+      control: process.platform !== 'darwin',
+      alt: false,
+      meta: process.platform === 'darwin',
+    })
+
+    // The page never sees it — otherwise a site's own Mod+F wins over find.
+    expect(event.preventDefault).toHaveBeenCalled()
+    expect(win.webContents.send).toHaveBeenLastCalledWith('browser-agent:open-find')
+  })
+
+  it('restarts the search while typing and steps without restarting on next/previous', () => {
+    panel.setPanelBounds({ x: 100, y: 50, width: 800, height: 600 })
+    const tab = session.requireTab()
+    const contents = (tab.view as unknown as MockView).webContents
+
+    session.findInActiveTab({ query: 'needle', findNext: false, forward: true })
+    expect(contents.findInPage).toHaveBeenLastCalledWith('needle', {
+      forward: true,
+      findNext: false,
+    })
+
+    session.findInActiveTab({ query: 'needle', findNext: true, forward: false })
+    expect(contents.findInPage).toHaveBeenLastCalledWith('needle', {
+      forward: false,
+      findNext: true,
+    })
+
+    // Clearing the box is a stop, not a search for the empty string — and the
+    // bar has to survive it, or deleting the last character closes the bar the
+    // user is still typing in.
+    vi.mocked(win.webContents.send).mockClear()
+    session.findInActiveTab({ query: '', findNext: false, forward: true })
+    expect(contents.stopFindInPage).toHaveBeenCalledWith('clearSelection')
+    expect(contents.findInPage).toHaveBeenCalledTimes(2)
+    expect(win.webContents.send).not.toHaveBeenCalledWith('browser-agent:close-find')
+  })
+
+  it('forwards match counts only for the tab the find is running on', () => {
+    panel.setPanelBounds({ x: 100, y: 50, width: 800, height: 600 })
+    const first = session.requireTab()
+    const second = session.addTab()
+    const firstContents = (first.view as unknown as MockView).webContents
+    const secondContents = (second.view as unknown as MockView).webContents
+    const foundOn = (contents: MockView['webContents']) =>
+      contents.on.mock.calls.find(([eventName]) => eventName === 'found-in-page')?.[1] as
+        | ((event: unknown, result: Record<string, unknown>) => void)
+        | undefined
+
+    session.switchTab(first.id)
+    session.findInActiveTab({ query: 'needle', findNext: false, forward: true })
+    foundOn(firstContents)?.({}, { activeMatchOrdinal: 2, matches: 7, finalUpdate: true })
+    expect(win.webContents.send).toHaveBeenLastCalledWith('browser-agent:find-result', {
+      activeMatchOrdinal: 2,
+      matches: 7,
+      final: true,
+    })
+
+    // A late result from a tab that is not being searched would relabel the bar
+    // with counts for a page the user is not looking at.
+    vi.mocked(win.webContents.send).mockClear()
+    foundOn(secondContents)?.({}, { activeMatchOrdinal: 1, matches: 3, finalUpdate: true })
+    expect(win.webContents.send).not.toHaveBeenCalledWith(
+      'browser-agent:find-result',
+      expect.anything()
+    )
+  })
+
+  it('drops the find when its page navigates away, but not on a same-document change', () => {
+    panel.setPanelBounds({ x: 100, y: 50, width: 800, height: 600 })
+    const tab = session.requireTab()
+    const contents = (tab.view as unknown as MockView).webContents
+    const navigate = contents.on.mock.calls.find(
+      ([eventName]) => eventName === 'did-start-navigation'
+    )?.[1] as ((details: Record<string, unknown>) => void) | undefined
+
+    session.findInActiveTab({ query: 'needle', findNext: false, forward: true })
+    vi.mocked(win.webContents.send).mockClear()
+
+    // A pushState route change keeps the document the matches live in.
+    navigate?.({ isMainFrame: true, isSameDocument: true })
+    expect(win.webContents.send).not.toHaveBeenCalledWith('browser-agent:close-find')
+    // A subframe load likewise leaves the main document alone.
+    navigate?.({ isMainFrame: false, isSameDocument: false })
+    expect(win.webContents.send).not.toHaveBeenCalledWith('browser-agent:close-find')
+
+    navigate?.({ isMainFrame: true, isSameDocument: false })
+    expect(contents.stopFindInPage).toHaveBeenCalledWith('clearSelection')
+    expect(win.webContents.send).toHaveBeenCalledWith('browser-agent:close-find')
+  })
+
+  it('drops the find when the user switches to another tab', () => {
+    panel.setPanelBounds({ x: 100, y: 50, width: 800, height: 600 })
+    const first = session.requireTab()
+    const second = session.addTab()
+    const firstContents = (first.view as unknown as MockView).webContents
+
+    session.switchTab(first.id)
+    session.findInActiveTab({ query: 'needle', findNext: false, forward: true })
+    vi.mocked(win.webContents.send).mockClear()
+
+    session.switchTab(second.id)
+    expect(firstContents.stopFindInPage).toHaveBeenCalledWith('clearSelection')
+    expect(win.webContents.send).toHaveBeenCalledWith('browser-agent:close-find')
+  })
+
+  it('returns focus to the page only when the user dismissed the bar', () => {
+    panel.setPanelBounds({ x: 100, y: 50, width: 800, height: 600 })
+    const tab = session.requireTab()
+    const contents = (tab.view as unknown as MockView).webContents
+
+    // Panel teardown: the bar unmounts under a user who has already moved on,
+    // so pulling focus back into the browser would drag them back to it.
+    session.findInActiveTab({ query: 'needle', findNext: false, forward: true })
+    contents.focus.mockClear()
+    session.stopFindInActiveTab(false)
+    expect(contents.focus).not.toHaveBeenCalled()
+
+    session.findInActiveTab({ query: 'needle', findNext: false, forward: true })
+    contents.focus.mockClear()
+    session.stopFindInActiveTab(true)
+    expect(contents.focus).toHaveBeenCalled()
+  })
+
+  it('returns focus to the page even when no search was running', () => {
+    panel.setPanelBounds({ x: 100, y: 50, width: 800, height: 600 })
+    const tab = session.requireTab()
+    const contents = (tab.view as unknown as MockView).webContents
+
+    // Opened and closed without typing. Focus still has to leave the bar: it is
+    // unmounting, and <body> cannot receive the Mod+F that reopens it.
+    contents.focus.mockClear()
+    session.stopFindInActiveTab(true)
+    expect(contents.focus).toHaveBeenCalled()
+
+    // Same once the box is emptied — clearing the query ends the search, so
+    // dismissing afterwards has no searched tab to key focus off either.
+    session.findInActiveTab({ query: 'needle', findNext: false, forward: true })
+    session.findInActiveTab({ query: '', findNext: false, forward: true })
+    contents.focus.mockClear()
+    session.stopFindInActiveTab(true)
+    expect(contents.focus).toHaveBeenCalled()
+  })
+
   it('closes only the native browser tab targeted by the application menu accelerator', () => {
     panel.setPanelBounds({ x: 100, y: 50, width: 800, height: 600 })
     const first = session.requireTab()

apps/desktop/src/main/browser-agent/session.ts

@@ -1,6 +1,8 @@
 import { join } from 'node:path'
 import {
   type BrowserDataKind,
+  type BrowserFindRequest,
+  type BrowserFindResult,
   type BrowserOmniboxFocusMode,
   type BrowserTabState,
   type BrowserTabsState,
@@ -74,7 +76,7 @@ export interface AgentSessionEvents {
  */
 const MAX_RECENTLY_CLOSED_TABS = 10
 
-export type BrowserShortcut = 'focus-omnibox' | 'new-tab' | 'close-tab'
+export type BrowserShortcut = 'focus-omnibox' | 'new-tab' | 'close-tab' | 'find'
 
 type BrowserShortcutInput = Pick<
   Input,
@@ -108,6 +110,8 @@ export function browserShortcutForInput(
       return 'new-tab'
     case 'w':
       return 'close-tab'
+    case 'f':
+      return 'find'
     default:
       return null
   }
@@ -304,6 +308,106 @@ function focusRendererOmnibox(mode: BrowserOmniboxFocusMode): void {
   win.webContents.send('browser-agent:focus-omnibox', mode)
 }
 
+/**
+ * Opens the renderer's find bar and moves keyboard focus to it. The bar is
+ * renderer chrome rather than an overlay on the page: a renderer element that
+ * overlapped the native view would trip the occlusion path and hide the very
+ * page being searched.
+ */
+function openRendererFind(): void {
+  const win = panelWindow()
+  if (!win || win.isDestroyed()) return
+  win.webContents.focus()
+  win.webContents.send('browser-agent:open-find')
+}
+
+/**
+ * Tab a find is currently running on. Tracked because the find outlives the
+ * call that started it — Chromium keeps the highlights until it is told to
+ * stop, so leaving a tab (or navigating it) has to clear the find explicitly
+ * or the old matches stay lit under a match count that no longer describes
+ * anything on screen.
+ */
+let findingTabId: string | null = null
+
+/**
+ * Drops a tab's highlights and stops treating it as the tab being searched.
+ * Leaves the renderer's bar alone — emptying the find box and searching a
+ * different tab both end a find while the user is still typing in the bar.
+ */
+function stopFindOnTab(tabId: string | null): void {
+  if (tabId === null) return
+  const tab = tabs.find((entry) => entry.id === tabId)
+  if (tab && !tab.view.webContents.isDestroyed()) {
+    tab.view.webContents.stopFindInPage('clearSelection')
+  }
+  if (findingTabId === tabId) findingTabId = null
+}
+
+/**
+ * Stops the find and dismisses the renderer's bar, for when the page it was
+ * run against is gone — a navigation or a tab switch. Chrome dismisses find on
+ * navigation too, and a count for the previous document is worse than no bar.
+ */
+function dismissFind(tabId: string | null): void {
+  if (tabId === null) return
+  const wasFinding = findingTabId === tabId
+  stopFindOnTab(tabId)
+  if (!wasFinding) return
+  const win = panelWindow()
+  if (win && !win.isDestroyed()) {
+    win.webContents.send('browser-agent:close-find')
+  }
+}
+
+/**
+ * Runs Chromium's own find against the active tab. An empty query stops the
+ * find rather than searching for nothing, matching what emptying Chrome's find
+ * box does — the bar stays open and ready for the next query.
+ */
+export function findInActiveTab(request: BrowserFindRequest): void {
+  const tab = activeTab()
+  if (!tab) return
+  if (request.query === '') {
+    stopFindOnTab(tab.id)
+    return
+  }
+  // A find started on another tab has to go before this one begins, or its
+  // highlights survive on a page the user can no longer see them on.
+  if (findingTabId !== null && findingTabId !== tab.id) stopFindOnTab(findingTabId)
+  findingTabId = tab.id
+  tab.view.webContents.findInPage(request.query, {
+    forward: request.forward,
+    findNext: request.findNext,
+  })
+}
+
+/**
+ * Stops the running find.
+ *
+ * `focusPage` distinguishes the user dismissing the bar — where focus is being
+ * pulled out from under them and Chrome leaves it on the page — from the bar
+ * merely unmounting because the browser panel went away. Only the renderer can
+ * tell those apart: the panel's own teardown reports bounds after its
+ * children's cleanups run, so by the time this is reached the panel still
+ * looks visible either way, and focusing the page on teardown would drag the
+ * user back to a browser they just navigated away from.
+ */
+export function stopFindInActiveTab(focusPage: boolean): void {
+  stopFindOnTab(findingTabId)
+  if (!focusPage) return
+  // Deliberately the ACTIVE tab, not whichever tab was being searched: there is
+  // often no search running at all (the bar was opened and closed without a
+  // query, or the box was emptied first, both of which clear the searched tab).
+  // Keying focus off the search left those cases with focus on the input that
+  // just unmounted, which lands on <body> — from there the page cannot receive
+  // the next Mod+F for the shell to intercept, and the renderer's own handler
+  // is scoped to the panel, so find became unopenable until something else was
+  // clicked.
+  const tab = activeTab()
+  if (tab) tab.view.webContents.focus()
+}
+
 /**
  * Opens a link from a page in another tab of this browser. Shared by the
  * window.open interception and the page's right-click menu — both have to stay
@@ -405,6 +509,10 @@ function createTabView(): WebContentsView {
       focusRendererOmnibox('select')
       return
     }
+    if (shortcut === 'find') {
+      openRendererFind()
+      return
+    }
     if (shortcut === 'new-tab') {
       if (listTabs().length < MAX_BROWSER_TABS) {
         addTab()
@@ -416,6 +524,28 @@ function createTabView(): WebContentsView {
     const tab = tabs.find((entry) => entry.view === view)
     if (tab) closeTabFromUser(tab.id)
   })
+  contents.on('found-in-page', (_event, result) => {
+    const tab = tabs.find((entry) => entry.view === view)
+    // Counts from a tab the user has already left would relabel the bar for
+    // whatever page is on screen now.
+    if (!tab || tab.id !== findingTabId) return
+    const win = panelWindow()
+    if (!win || win.isDestroyed()) return
+    const payload: BrowserFindResult = {
+      activeMatchOrdinal: result.activeMatchOrdinal,
+      matches: result.matches,
+      final: result.finalUpdate,
+    }
+    win.webContents.send('browser-agent:find-result', payload)
+  })
+  // A document load replaces what the find was pointing at. Same-document
+  // route changes do not, and Chromium keeps the highlights across them, so
+  // only real navigations dismiss the bar.
+  contents.on('did-start-navigation', (details) => {
+    if (!details.isMainFrame || details.isSameDocument) return
+    const tab = tabs.find((entry) => entry.view === view)
+    if (tab) dismissFind(tab.id)
+  })
   // A pinned tab persists its latest top-level location, including
   // user-driven navigations that do not pass through the driver.
   contents.on('did-navigate', persistPinnedTabs)
@@ -634,6 +764,8 @@ export function switchTab(tabId: string): AgentTab {
   restorePinnedTabs()
   const tab = tabs.find((entry) => entry.id === tabId)
   if (!tab) throw new SessionError(`No tab with id ${tabId} — call browser_list_tabs.`)
+  // The find belongs to the page it was typed against, not to the browser.
+  if (findingTabId !== null && findingTabId !== tab.id) dismissFind(findingTabId)
   const transferBrowserFocus =
     focusedBrowserTabId !== null || tabs.some((entry) => entry.view.webContents.isFocused())
   activeTabId = tab.id