From 1c4dc4cf5f60dfa5bba87203eabbe841d265c9e9 Mon Sep 17 00:00:00 2001 From: ethernet Date: Tue, 18 Aug 2026 16:36:26 -0400 Subject: [PATCH] fix(desktop): collapse the docked Bots tab with the sessions sidebar on narrow viewports The Bots pane docks into the sessions zone but did not declare collapsible. Below the sidebar-collapse breakpoint, the sessions pane left the grid and the zone kept a stranded BOTS tab on screen. The Bots pane now declares collapsible, so it leaves the grid with its zone. The narrow edge overlay now mirrors the zone's tab strip when the revealed pane has collapsed zone-mates. Without the strip, only the first pane of the zone was reachable while collapsed. A lone pane keeps the stripless overlay form. --- .../tree/renderer/narrow-overlays.test.tsx | 99 +++++++++++++++++++ .../tree/renderer/narrow-overlays.tsx | 41 +++++++- .../desktop/src/plugins/hermes-bots/plugin.js | 7 +- 3 files changed, 145 insertions(+), 2 deletions(-) create mode 100644 apps/desktop/src/components/pane-shell/tree/renderer/narrow-overlays.test.tsx diff --git a/apps/desktop/src/components/pane-shell/tree/renderer/narrow-overlays.test.tsx b/apps/desktop/src/components/pane-shell/tree/renderer/narrow-overlays.test.tsx new file mode 100644 index 0000000000..40f6e9fcfc --- /dev/null +++ b/apps/desktop/src/components/pane-shell/tree/renderer/narrow-overlays.test.tsx @@ -0,0 +1,99 @@ +import { act, cleanup, fireEvent, render } from '@testing-library/react' +import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest' + +import { PANE_TOGGLE_REVEAL_EVENT } from '@/components/pane-shell' +import { registry } from '@/contrib/registry' + +import { group, split } from '../model' +import { $hiddenTreePanes, $layoutTree, $narrowViewport, declareDefaultTree } from '../store' + +import { NarrowOverlays } from './narrow-overlays' + +// Ground truth for "the Bots tab is still visible when the sessions sidebar +// collapses on a narrow window". A collapsible pane DOCKED into the sessions +// zone (SESSIONS | BOTS) must leave the grid with the zone, and the narrow +// edge overlay must mirror the zone's tab strip so the docked pane stays +// reachable — not just the zone's first pane. + +class TestResizeObserver { + observe() {} + unobserve() {} + disconnect() {} +} + +beforeAll(() => { + vi.stubGlobal('ResizeObserver', TestResizeObserver) +}) + +const disposers: (() => void)[] = [] + +const registerPane = (id: string, title: string, data: Record, body: string) => { + disposers.push( + registry.register({ + area: 'panes', + data, + id, + render: () =>
{body}
, + title + }) + ) +} + +beforeEach(() => { + window.localStorage.clear() + $hiddenTreePanes.set(new Set()) + + registerPane('sessions', 'sessions', { collapsible: true, placement: 'left', width: '237px' }, 'session rows') + registerPane('bots', 'Bots', { collapsible: true, placement: 'left', width: '260px' }, 'bot roster') + registerPane('workspace', 'workspace', { placement: 'main', uncloseable: true }, 'chat') + + declareDefaultTree(split('row', [group(['sessions', 'bots']), group(['workspace'])])) + $narrowViewport.set(true) +}) + +afterEach(() => { + cleanup() + $narrowViewport.set(false) + $layoutTree.set(null) + disposers.splice(0).forEach(dispose => dispose()) +}) + +const revealPane = (id: string) => { + act(() => { + window.dispatchEvent(new CustomEvent(PANE_TOGGLE_REVEAL_EVENT, { detail: { id, mode: 'open' } })) + }) +} + +const overlayTab = (paneId: string) => document.querySelector(`[data-narrow-overlay-tab="${paneId}"]`) + +describe('narrow overlay of a stacked zone', () => { + it('mirrors the zone tab strip so every stacked collapsible stays reachable', () => { + const { getByTestId, queryByTestId } = render() + + revealPane('sessions') + + // Both zone-mates surface as tabs; the revealed pane's body is on screen. + expect(overlayTab('sessions')).toBeTruthy() + expect(overlayTab('bots')).toBeTruthy() + expect(getByTestId('sessions-body')).toBeTruthy() + expect(queryByTestId('bots-body')).toBeNull() + + // Clicking the BOTS tab swaps the overlay to the docked pane. + fireEvent.pointerDown(overlayTab('bots')!, { button: 0 }) + expect(getByTestId('bots-body')).toBeTruthy() + expect(queryByTestId('sessions-body')).toBeNull() + }) + + it('keeps the stripless form for a zone with a single collapsible', () => { + // Direct set: declareDefaultTree only ADOPTS into an existing tree — it + // would keep the beforeEach zone (with bots) instead of replacing it. + $layoutTree.set(split('row', [group(['sessions']), group(['workspace'])])) + + const { getByTestId } = render() + + revealPane('sessions') + + expect(getByTestId('sessions-body')).toBeTruthy() + expect(overlayTab('sessions')).toBeNull() + }) +}) diff --git a/apps/desktop/src/components/pane-shell/tree/renderer/narrow-overlays.tsx b/apps/desktop/src/components/pane-shell/tree/renderer/narrow-overlays.tsx index 3c695cf19b..02ef04adaa 100644 --- a/apps/desktop/src/components/pane-shell/tree/renderer/narrow-overlays.tsx +++ b/apps/desktop/src/components/pane-shell/tree/renderer/narrow-overlays.tsx @@ -9,6 +9,7 @@ import { useStore } from '@nanostores/react' import { useEffect, useMemo, useRef, useState } from 'react' +import { PaneTab, PaneTabLabel, PaneTabStrip } from '@/components/ui/pane-tab' import { ContribBoundary, ContribRender } from '@/contrib/react/boundary' import { useContributions } from '@/contrib/react/use-contributions' import type { Contribution } from '@/contrib/types' @@ -16,7 +17,7 @@ import { ESCAPE_PRIORITY, isTopEscapeLayer, pushEscapeLayer } from '@/lib/escape import { cn } from '@/lib/utils' import { PANE_TOGGLE_REVEAL_EVENT } from '../..' -import { allPaneIds } from '../model' +import { allPaneIds, findGroupOfPane } from '../model' import { $hiddenTreePanes, $layoutTree, $narrowViewport } from '../store' import { paneChrome } from './track-model' @@ -108,6 +109,22 @@ export function NarrowOverlays() { const revealed = reveal ? collapsibles.find(p => p.id === reveal.id) : undefined const sides = [...new Set(collapsibles.map(sideOf))] + // The revealed pane's ZONE-mates that also left the grid (the sessions zone + // stacks SESSIONS | BOTS): the overlay mirrors the zone's tab strip so a + // pane docked into a collapsed zone stays reachable on narrow viewports — + // without this, only the zone's first pane ever surfaces again. + const zonePanes = (() => { + if (!revealed || !tree) { + return [revealed].filter((p): p is Contribution => Boolean(p)) + } + + const zone = findGroupOfPane(tree, revealed.id) + const mates = zone ? zone.panes.map(id => collapsibles.find(p => p.id === id)) : [] + const shown = mates.filter((p): p is Contribution => Boolean(p)) + + return shown.length > 0 ? shown : [revealed] + })() + return ( <> {/* Hover-intent strips on each edge that has a collapsed pane. */} @@ -138,6 +155,28 @@ export function NarrowOverlays() { // width) instead of a fat fixed 20rem — capped for tiny screens. style={{ width: `min(${(revealed.data as { width?: string } | undefined)?.width ?? '18rem'}, 85vw)` }} > + {/* Zone-mates share the overlay through the zone's own tab strip + (SESSIONS | BOTS) — a lone pane keeps the stripless form. */} + {zonePanes.length > 1 && ( + + {zonePanes.map(pane => ( + { + if (event.button === 0) { + event.preventDefault() + setReveal(current => ({ id: pane.id, pinned: current?.pinned ?? false })) + } + }} + > + {pane.title ?? pane.id} + + ))} + + )} {revealed.render && } diff --git a/apps/desktop/src/plugins/hermes-bots/plugin.js b/apps/desktop/src/plugins/hermes-bots/plugin.js index de4c7ef123..0203a04623 100644 --- a/apps/desktop/src/plugins/hermes-bots/plugin.js +++ b/apps/desktop/src/plugins/hermes-bots/plugin.js @@ -9366,7 +9366,12 @@ export default { // An intra-session drag still sticks until the next launch (the // invariant runs at adoption time only — see enforceDockedPanes in the // tree store). - data: { placement: 'left', width: '260px', dock: { pane: 'sessions', pos: 'center', enforce: true } }, + // collapsible: the pane lives in the sessions zone, so it must LEAVE + // the grid with that zone below the sidebar-collapse breakpoint. The + // sessions pane collapses alone without this flag. The zone then keeps + // a stranded BOTS tab on screen. The narrow edge overlay mirrors the + // zone's tab strip, so the pane stays reachable while collapsed. + data: { placement: 'left', width: '260px', collapsible: true, dock: { pane: 'sessions', pos: 'center', enforce: true } }, render: () => jsx(BotsPane, {}) })