hop2 0.11.41 → 0.11.43

package/hay/apps/web/src/components/SessionSwitcher.tsx

@@ -1636,7 +1636,18 @@ export const SessionSwitcher = ({
   // sessions that vanish drop out; brand-new ones append at the end rather
   // than reshuffling the wall.
   const frozenOrderRef = useRef<{ mode: "tiers" | "project"; hero: string[]; groups: Array<{ label: string; rows: string[] }> } | null>(null);
-  useEffect(() => { if (!open) frozenOrderRef.current = null; }, [open]);
+  // Search results freeze the same way, per QUERY: the order you see is the
+  // order at the moment you searched. Score ties break on attention and
+  // recency, and manual mode's unplaced rows sort by name, so without this a
+  // bell, an activity tick, a rename, or a fresh tagline re-sorted the
+  // results under the cursor. New matches join at the end; matches that
+  // stop matching drop; a new query, or the user's own drag, recaptures.
+  const frozenQueryRef = useRef<
+    | { mode: "filter"; query: string; manualOrder: string[]; rows: string[] }
+    | { mode: "manual"; query: string; manualOrder: string[]; loose: string[]; folders: Array<{ id: string; rows: string[] }> }
+    | null
+  >(null);
+  useEffect(() => { if (!open) { frozenOrderRef.current = null; frozenQueryRef.current = null; } }, [open]);
   // A non-empty query, whichever render branch the model picks for it.
   const searching = filter.trim().length > 0;
   const model = useMemo(() => {
@@ -1644,7 +1655,48 @@ export const SessionSwitcher = ({
     // wall shows only unparked sessions.
     const pool = filter.trim() ? visibleSessions : wallSessions;
     const live = buildSwitcherModel(pool, currentRoom, filter, sortMode, manualOrder, folders);
-    if (!open || (live.mode !== "tiers" && live.mode !== "project")) return live;
+    if (!open) return live;
+    const query = filter.trim();
+    if (live.mode === "filter" || (live.mode === "manual" && query)) {
+      const fq = frozenQueryRef.current;
+      const stale = !fq || fq.mode !== live.mode || fq.query !== query || fq.manualOrder !== manualOrder;
+      if (stale) {
+        frozenQueryRef.current = live.mode === "filter"
+          ? { mode: "filter", query, manualOrder, rows: live.rows.map(sessionKey) }
+          : {
+              mode: "manual", query, manualOrder,
+              loose: live.rows.map(sessionKey),
+              folders: live.folders.map((f) => ({ id: f.folder.id, rows: f.rows.map(sessionKey) }))
+            };
+        return live;
+      }
+      // Resolve against what still MATCHES (the live rows), never the whole
+      // pool: a session that stopped matching leaves, one that started
+      // matching joins at the end, and nothing in between moves.
+      const pin = (frozenKeys: string[], liveRows: SwitcherSession[]) => {
+        const byKey = new Map(liveRows.map((r) => [sessionKey(r), r]));
+        const known = new Set(frozenKeys);
+        return [
+          ...frozenKeys.map((k) => byKey.get(k)).filter((r): r is SwitcherSession => !!r),
+          ...liveRows.filter((r) => !known.has(sessionKey(r)))
+        ];
+      };
+      if (live.mode === "filter" && fq.mode === "filter") {
+        return { mode: "filter" as const, rows: pin(fq.rows, live.rows) };
+      }
+      if (live.mode === "manual" && fq.mode === "manual") {
+        return {
+          mode: "manual" as const,
+          rows: pin(fq.loose, live.rows),
+          folders: live.folders.map((f) => {
+            const fz = fq.folders.find((x) => x.id === f.folder.id);
+            return fz ? { folder: f.folder, rows: pin(fz.rows, f.rows) } : f;
+          })
+        };
+      }
+      return live;
+    }
+    if (live.mode !== "tiers" && live.mode !== "project") return live;
     let frozen = frozenOrderRef.current;
     if (!frozen || frozen.mode !== live.mode) {
       frozen = live.mode === "tiers"

package/hay/apps/web/src/components/ViewsPanel.tsx

@@ -247,7 +247,11 @@ export const ViewsPanel = ({ session, sessions = [], dock = false, onClose }: Pr
     const onKey = (event: KeyboardEvent) => {
       if (docked) {
         const el = panelRef.current;
-        const target = event.target as Node | null;
+        // A keydown dispatched on `window` (tests do this; so does a page with
+        // nothing focused) has a target that is not a Node, and jsdom throws
+        // on contains() for it — which took the whole test run down as an
+        // unhandled error. Only a Node can be inside the panel.
+        const target = event.target instanceof Node ? event.target : null;
         const inside = !!el && ((target && el.contains(target))
           || (document.activeElement && el.contains(document.activeElement)));
         if (!inside) return;

package/hay/apps/web/test/SessionSwitcher.test.tsx

@@ -307,6 +307,50 @@ describe("context menus", () => {
   });
 });
 
+describe("search results hold their order", () => {
+  afterEach(() => { document.body.innerHTML = ""; localStorage.removeItem("hay_sort_mode"); });
+  const mk = (name: string, activity: number, extra: Partial<SwitcherSession> = {}): SwitcherSession =>
+    ({ name, displayName: name, internalName: name, active: true, starting: false, createdBy: "user", lastActivityAt: activity, ...extra });
+  const order = () => Array.from(document.querySelectorAll(".switcher-card[data-session-key]")).map((c) => c.getAttribute("data-session-key"));
+  const typeQuery = (q: string) => {
+    const input = document.querySelector(".switcher-top input") as HTMLInputElement;
+    fireEvent.change(input, { target: { value: q } });
+  };
+  // Both names match "vault" as a prefix with equal score, so the tie-break
+  // (attention, then recency) decides — which is exactly what must not keep
+  // deciding after the search.
+  const two = (a: Partial<SwitcherSession> = {}, b: Partial<SwitcherSession> = {}) =>
+    [mk("vault-a", 1000, a), mk("vault-b", 2000, b)];
+
+  it("in Recent mode: activity, bells and new matches do not reorder the results you searched", () => {
+    localStorage.setItem("hay_sort_mode", "recent");
+    const view = render(<SessionSwitcher {...props} sessions={two()} open />);
+    typeQuery("vault");
+    expect(order()).toEqual(["vault-b", "vault-a"]); // recency ranks b first — at search time
+    // a becomes the most active and rings a bell: it would now rank first.
+    view.rerender(<SessionSwitcher {...props} sessions={two({ lastActivityAt: 99000, bellUnseen: true })} open />);
+    expect(order()).toEqual(["vault-b", "vault-a"]);
+    // A new match joins at the end; one that stops matching leaves.
+    view.rerender(<SessionSwitcher {...props} sessions={[...two({ lastActivityAt: 99000 }), mk("vault-c", 500000)]} open />);
+    expect(order()).toEqual(["vault-b", "vault-a", "vault-c"]);
+    view.rerender(<SessionSwitcher {...props} sessions={[mk("vault-a", 99000), mk("vault-c", 500000)]} open />);
+    expect(order()).toEqual(["vault-a", "vault-c"]);
+    // A new query is a new search: ranked fresh.
+    typeQuery("vault-c");
+    expect(order()).toEqual(["vault-c"]);
+  });
+
+  it("in Manual mode: a rename mid-search does not move the card", () => {
+    localStorage.setItem("hay_sort_mode", "manual");
+    const view = render(<SessionSwitcher {...props} sessions={two()} open />);
+    typeQuery("vault");
+    expect(order()).toEqual(["vault-a", "vault-b"]); // unplaced rows: by name at search time
+    // a is renamed to something that sorts after b (and still matches).
+    view.rerender(<SessionSwitcher {...props} sessions={two({ displayName: "zz-vault-a" })} open />);
+    expect(order()).toEqual(["vault-a", "vault-b"]);
+  });
+});
+
 describe("manual folders in the wall", () => {
   afterEach(() => { document.body.innerHTML = ""; });
   const folders = [{ id: "f1", name: "Filed" }];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hop2",
-  "version": "0.11.41",
+  "version": "0.11.43",
   "description": "🐰 Hop into your terminal from anywhere. Secure remote shell access with 2FA via Cloudflare Tunnel. Next-gen rewrite with native terminal sharing.",
   "main": "hop",
   "bin": {