feat(pane): Follow Symlink / Reveal Source in the context menu

The file context menu gains a Follow row on entries where Shift+Enter
does something: "Reveal Source" when the entry carries a synthetic-VFS
alias (a search hit), "Follow Symlink" on a symlink, hidden otherwise —
the alias-beats-symlink precedence `cmd_follow_symlink` applies. The kind
is read off the row the commands will act on, which is the focused row
rather than the clicked one when the right-click lands inside a
multi-selection.

Two context-menu fixes ride along, same code:

Focus restoration. The file and pane menus never set `onCloseAutoFocus`,
so Radix aimed for whatever held focus when the menu opened. Opening one
context menu directly from another records a node inside the first menu,
which is unmounted moments later, and closing the second dropped focus to
`<body>`. All three menus now share one `refocusPane` callback.

Keyboard-requested menus. The Menu key does not reach the pane as a
bindable keydown; it surfaces only as a native `contextmenu` event the
webview aims by hit-testing a point of its own choosing — an unrelated
row, in whichever pane the point fell in, which also moved pane focus
there. Those are now recognised at the document level and relayed to the
active pane, which anchors the menu on its focused row. Shift+F10 and
right-click keep their existing path; the pane's own dispatch carries
button 2 to identify itself as pointer-positioned.

Author: tibordp

FEATURE_DUMP.md

@@ -265,6 +265,7 @@ The default browser context menu is suppressed in the main window (but not in th
 | Item | Shortcut |
 |------|----------|
 | Open | |
+| Follow Symlink / Reveal Source | Shift+Enter (symlinks and aliased entries only) |
 | View | F3 |
 | Edit | F4 |
 | Copy Path | Mod+C |
@@ -275,6 +276,8 @@ The default browser context menu is suppressed in the main window (but not in th
 | Properties | Alt+Enter |
 | Windows Menu | Shift+RClick (Windows host + host-local files only) |
 
+The Follow row appears only when it would do something: labelled "Reveal Source" on an entry carrying a synthetic-VFS alias (a search hit), "Follow Symlink" on a symlink, absent otherwise — the same precedence `cmd_follow_symlink` applies. Like the rest of the menu it describes the entry the commands act on, which is the focused row rather than the clicked one when the right-click lands inside a multi-selection.
+
 **Right-click empty space** in the file list:
 
 | Item | Shortcut |

src/main_window/ContextMenu.tsx

@@ -44,22 +44,35 @@ function ShellMenuItem({ onShellMenu }: { onShellMenu?: () => void }) {
   );
 }
 
+/// What Shift+Enter offers on the entry the menu was opened over: the
+/// target of a symlink, or the real file behind a synthetic-VFS alias
+/// (a search hit). `null` on entries that are neither.
+export type FollowKind = "symlink" | "source" | null;
+
 type FileContextMenuProps = {
   paneHandle: number;
   isParentDir: boolean;
+  follow: FollowKind;
   onShellMenu?: () => void;
+  onCloseAutoFocus?: (e: Event) => void;
 };
 
 export function FileContextMenuContent({
   paneHandle,
   isParentDir,
+  follow,
   onShellMenu,
+  onCloseAutoFocus,
 }: FileContextMenuProps) {
   const commands = useCommands();
 
   return (
     <CM.Portal>
-      <CM.Content className={styles.content} loop>
+      <CM.Content
+        className={styles.content}
+        loop
+        onCloseAutoFocus={onCloseAutoFocus}
+      >
         <CM.Item
           className={styles.item}
           disabled={isParentDir}
@@ -68,6 +81,15 @@ export function FileContextMenuContent({
           Open
           <Shortcut commands={commands} id="open" />
         </CM.Item>
+        {follow && (
+          <CM.Item
+            className={styles.item}
+            onSelect={() => safe(ipc.cmdFollowSymlink(paneHandle))}
+          >
+            {follow === "source" ? "Reveal Source" : "Follow Symlink"}
+            <Shortcut commands={commands} id="follow_symlink" />
+          </CM.Item>
+        )}
         <CM.Item
           className={styles.item}
           disabled={isParentDir}
@@ -147,18 +169,24 @@ type PaneContextMenuProps = {
   paneHandle: number;
   isHostLocal: boolean;
   onShellMenu?: () => void;
+  onCloseAutoFocus?: (e: Event) => void;
 };
 
 export function PaneContextMenuContent({
   paneHandle,
   isHostLocal,
   onShellMenu,
+  onCloseAutoFocus,
 }: PaneContextMenuProps) {
   const commands = useCommands();
 
   return (
     <CM.Portal>
-      <CM.Content className={styles.content} loop>
+      <CM.Content
+        className={styles.content}
+        loop
+        onCloseAutoFocus={onCloseAutoFocus}
+      >
         {isHostLocal && (
           <>
             <CM.Item

src/main_window/MainWindow.tsx

@@ -37,7 +37,11 @@ import {
 } from "../lib/commands";
 import ModalRouter from "./modals/ModalRouter";
 import OperationsPanel, { OperationProgressModal } from "./OperationsPanel";
-import { MainWindowState } from "./types";
+import {
+  KEYBOARD_MENU_EVENT,
+  MainWindowState,
+  isKeyboardContextMenu,
+} from "./types";
 import Pane from "./Pane";
 import TerminalPanel from "./TerminalPanel";
 import { usePreferences } from "../lib/preferences";
@@ -261,6 +265,9 @@ function App() {
         return;
       }
       e.preventDefault();
+      if (isKeyboardContextMenu(e)) {
+        window.dispatchEvent(new Event(KEYBOARD_MENU_EVENT));
+      }
     };
     document.addEventListener("contextmenu", handler);
     return () => document.removeEventListener("contextmenu", handler);

src/main_window/Pane.tsx

@@ -27,6 +27,8 @@ import {
   PaneState,
   DndFileInfo,
   FileRowContext,
+  KEYBOARD_MENU_EVENT,
+  isKeyboardContextMenu,
 } from "./types";
 import type { VfsProgress } from "../lib/bindings";
 import { useFormatBytes, useSizeUnits } from "../lib/size";
@@ -41,6 +43,7 @@ import {
   PaneContextMenuContent,
   BreadcrumbContextMenuContent,
   ColumnsContextMenuContent,
+  type FollowKind,
 } from "./ContextMenu";
 import styles from "./Pane.module.scss";
 import menuStyles from "./Menu.module.scss";
@@ -554,6 +557,15 @@ function FilterInput({
   return <div className={styles.filterInput}>{input}</div>;
 }
 
+/// What Shift+Enter would do on a row, or `null` when it would do nothing.
+/// An alias source wins over the entry's own symlink target, mirroring
+/// `cmd_follow_symlink`.
+function followKind(row: FileView | undefined): FollowKind {
+  if (!row) return null;
+  if (row.source_display) return "source";
+  return row.is_symlink ? "symlink" : null;
+}
+
 // --- Shared DnD helpers (used by both internal and external drag-and-drop) ---
 
 /** Clear all drop-target highlights in the document. */
@@ -825,6 +837,8 @@ function PaneInner(
   fileWindowRef.current = file_window;
   const selectedLookupRef = useRef(selectedLookup);
   selectedLookupRef.current = selectedLookup;
+  const focusedRef = useRef(focused);
+  focusedRef.current = focused;
 
   // --- DnD (drag-and-drop between panes) refs ---
   const dndRef = useRef<LocalDndState | null>(null);
@@ -1367,15 +1381,28 @@ function PaneInner(
     if (!li) return;
     const rect = li.getBoundingClientRect();
     setContextMenuIsParentDir(focused === "..");
+    // `button: 2` marks the event as carrying a real position — see the
+    // keyboard branch in `onContextMenu`.
     li.dispatchEvent(
       new MouseEvent("contextmenu", {
         bubbles: true,
+        button: 2,
+        buttons: 2,
         clientX: rect.left,
         clientY: rect.bottom,
       }),
     );
   }, [focused]);
 
+  // Serve keyboard-requested menus while this is the active pane, wherever
+  // the webview aimed its event (or if it never reached a pane at all).
+  useEffect(() => {
+    if (!active) return;
+    const onRequest = () => openContextMenu();
+    window.addEventListener(KEYBOARD_MENU_EVENT, onRequest);
+    return () => window.removeEventListener(KEYBOARD_MENU_EVENT, onRequest);
+  }, [active, openContextMenu]);
+
   const onkeydown = (e: React.KeyboardEvent<Element>) => {
     const { noModifiers } = modifiers(e);
 
@@ -1514,6 +1541,7 @@ function PaneInner(
   const contextMenuFileRef = useRef<string | null>(null);
   const contextMenuPosRef = useRef({ x: 0, y: 0 });
   const [contextMenuIsParentDir, setContextMenuIsParentDir] = useState(false);
+  const [contextMenuFollow, setContextMenuFollow] = useState<FollowKind>(null);
 
   const [contextMenuOnFile, setContextMenuOnFile] = useState(true);
 
@@ -1536,8 +1564,30 @@ function PaneInner(
     [paneHandle],
   );
 
+  /// Restore focus ourselves when a context menu closes. Radix would aim
+  /// for whatever held focus when the menu opened, which is a node inside
+  /// the previous menu whenever one context menu is opened directly from
+  /// another — unmounted by then, leaving focus on `<body>`. The column
+  /// header additionally isn't focusable at all.
+  const refocusPane = useCallback(
+    (e: Event) => {
+      e.preventDefault();
+      if (active && !modalOpen) {
+        (filter != null ? inputRef : containerRef).current?.focus();
+      }
+    },
+    [active, modalOpen, filter],
+  );
+
   const onContextMenu = useCallback(
     (e: React.MouseEvent<HTMLUListElement>) => {
+      // Keyboard-requested menu — MainWindow relays it to the active pane.
+      // preventDefault keeps Radix from anchoring at the webview's point.
+      if (isKeyboardContextMenu(e.nativeEvent)) {
+        e.preventDefault();
+        return;
+      }
+
       // Find which file row was right-clicked
       const target = e.target as HTMLElement;
       const li = target.closest("li[data-name]") as HTMLElement | null;
@@ -1555,6 +1605,7 @@ function PaneInner(
         // Right-clicked on empty space — show the pane-level context menu
         setContextMenuOnFile(false);
         setContextMenuIsParentDir(false);
+        setContextMenuFollow(null);
         return;
       }
 
@@ -1564,9 +1615,24 @@ function PaneInner(
       setContextMenuIsParentDir(fileName === "..");
 
       // If right-clicked file is not in the selection, focus it (clearing selection)
-      if (fileName !== ".." && !selectedLookupRef.current.has(fileName)) {
+      const inSelection = selectedLookupRef.current.has(fileName);
+      if (fileName !== ".." && !inSelection) {
         safeSilent(commands.focus(paneHandle, fileName));
       }
+
+      // Entry-specific items describe what the commands will act on: focus
+      // stays put when the click lands inside the selection, so that row —
+      // not the clicked one — is the target.
+      const targetKey = inSelection
+        ? (focusedRef.current ?? fileName)
+        : fileName;
+      setContextMenuFollow(
+        followKind(
+          fileWindowRef.current.items.find(
+            (f) => (f.key ?? f.name) === targetKey,
+          ),
+        ),
+      );
     },
     [paneHandle, shellMenuAvailable, openShellMenu],
   );
@@ -1857,14 +1923,7 @@ function PaneInner(
         <ColumnsContextMenuContent
           columns={preferences?.settings?.appearance?.columns}
           traits={metadata_traits}
-          onCloseAutoFocus={(e) => {
-            // The header is not focusable — mirror the pane focus effect
-            // instead of letting Radix focus the trigger div.
-            e.preventDefault();
-            if (active && !modalOpen) {
-              (filter != null ? inputRef : containerRef).current?.focus();
-            }
-          }}
+          onCloseAutoFocus={refocusPane}
         />
       </ContextMenu.Root>
       {file_window && (
@@ -1920,6 +1979,8 @@ function PaneInner(
             <FileContextMenuContent
               paneHandle={paneHandle}
               isParentDir={contextMenuIsParentDir}
+              follow={contextMenuFollow}
+              onCloseAutoFocus={refocusPane}
               onShellMenu={
                 shellMenuAvailable
                   ? () => void openShellMenu(contextMenuFileRef.current)
@@ -1930,6 +1991,7 @@ function PaneInner(
             <PaneContextMenuContent
               paneHandle={paneHandle}
               isHostLocal={props.is_host_local}
+              onCloseAutoFocus={refocusPane}
               onShellMenu={
                 shellMenuAvailable ? () => void openShellMenu(null) : undefined
               }

src/main_window/types.ts

@@ -164,6 +164,21 @@ export type Terminal = {
 /// doesn't drift when DndFile gains optional fields.
 export type DndFileInfo = DndFile;
 
+/// Window event carrying a keyboard-requested context menu to the active
+/// pane, dispatched by the document-level handler in MainWindow.
+export const KEYBOARD_MENU_EVENT = "newt:keyboard-context-menu";
+
+/// Whether a `contextmenu` event came from the keyboard rather than a
+/// pointer. The Menu key produces no keydown the panes can bind, only this
+/// event, and the webview aims it by hit-testing a point of its own
+/// choosing — an unrelated row, in whichever pane the point fell in — so it
+/// must be recognised and re-routed rather than acted on where it landed.
+/// A pointer carries button 2; macOS ctrl+click reports no button either,
+/// but carries `ctrlKey`.
+export function isKeyboardContextMenu(e: MouseEvent): boolean {
+  return e.button !== 2 && !e.ctrlKey;
+}
+
 export type MainWindowState = {
   connection_status: ConnectionStatus;
   askpass?: AskpassPrompt;