hop2 0.11.53 → 0.11.55

package/hay/apps/web/src/App.tsx

@@ -19,6 +19,7 @@ import { remoteAppOwnsScreen } from "./utils/echoGuard";
 import { urlAtCell, cellAtPoint } from "./utils/urlAtCell";
 import { scanKeyboardProtocol } from "./utils/keyboardProtocol";
 import { originalPathHint, pasteableUploadPaths } from "./utils/fileDrop";
+import { claimOnAttach, claimOnClick } from "./utils/sizeClaim";
 import { MobileKeyboard } from "./components/MobileKeyboard";
 import { SessionSwitcher } from "./components/SessionSwitcher";
 import { SecondaryPane } from "./components/SecondaryPane";
@@ -1348,7 +1349,11 @@ const App = () => {
   const killArmedAtRef = useRef(0);
   // Set by an explicit session switch; the next attach claim carries
   // user:true (deliberate — wins the size election outright on new hosts).
-  const deliberateAttachRef = useRef(false);
+  // A page load is the human opening this session, so the first attach may
+  // claim the size. Every later attach must be re-armed by an actual act (a
+  // switch, closing the wall into the session, a click, the Fit button) —
+  // a reconnect is the socket healing itself, not a person.
+  const deliberateAttachRef = useRef(true);
   // A canvas that was HIDDEN can come back showing a stale frame: the wall
   // covers the terminal with visibility:hidden, browsers throttle or drop
   // WebGL contexts for hidden canvases, and xterm only repaints rows it
@@ -1491,6 +1496,24 @@ const App = () => {
     });
   };
 
+  /**
+   * Take the session's size for THIS viewport, because the user just acted
+   * here. Quiet when the session is already at our fit, so an ordinary click
+   * (or a selection drag) never pushes a resize.
+   */
+  const claimSizeHere = (force = false) => {
+    if (!force && !claimOnClick({
+      viewMode: viewModeRef.current,
+      natural: measureNaturalFit(),
+      active: activeSizeRef.current,
+      owned: activeOwnerRef.current === clientIdRef.current
+    })) return;
+    attachClaimPendingRef.current = true;
+    deliberateAttachRef.current = true;
+    fitToViewport();
+    handleResize();
+  };
+
   // Scale the owner's grid to this viewport (letterboxed, centered
   // horizontally) — a follower renders the PTY's true grid, never rewraps
   // it. Transform only: bounds and cell metrics stay honest, so natural-fit
@@ -1904,10 +1927,14 @@ const App = () => {
           // ownership of the shared size outright — but only when someone is
           // actually LOOKING. A hidden tab's auto-reconnect is not an opening;
           // claiming from it would yank the size from whoever is present.
+          if (claimOnAttach({
+            viewMode: viewModeRef.current,
+            visible: document.visibilityState === "visible",
+            deliberate: deliberateAttachRef.current
+          })) {
+            attachClaimPendingRef.current = true;
+          }
           if (viewModeRef.current === "fit") {
-            if (document.visibilityState === "visible") {
-              attachClaimPendingRef.current = true;
-            }
             fitWhenReady(12, () => termRef.current?.scrollToBottom());
           }
           break;
@@ -4331,11 +4358,8 @@ const App = () => {
               <div className="quick-group">
                 <button type="button" className="quick-btn" onClick={() => {
                   // An explicit Fit is a deliberate act: claim the size, even
-                  // from a peer that owns it.
-                  attachClaimPendingRef.current = true;
-                  deliberateAttachRef.current = true;
-                  fitToViewport();
-                  handleResize();
+                  // from a peer that owns it, and even if we think we fit.
+                  claimSizeHere(true);
                 }}>
                   Fit
                 </button>
@@ -4564,6 +4588,10 @@ const App = () => {
                     if (!isMobile) {
                       termRef.current?.focus();
                     }
+                    // A click here is a human act on this surface, so it may
+                    // take a size some other window left behind. No-op when
+                    // the session already fits this viewport.
+                    claimSizeHere();
                   }}
                   onDragEnter={(e) => {
                     if (Array.from(e.dataTransfer?.types || []).includes("Files")) {

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

@@ -28,7 +28,8 @@ import {
   type SessionOriginScope,
   type SwitcherFolder,
   type SwitcherSession,
-  type SwitcherSortMode
+  type SwitcherSortMode,
+  insertAfter
 } from "../utils/switcherModel";
 import { scanKeyboardProtocol } from "../utils/keyboardProtocol";
 import { DigestCard } from "./DigestCard";
@@ -815,6 +816,8 @@ const LiveTile = ({ wsBase, room, userName, theme, live, claudeApp, claimSize, a
   };
   const claimRef = useRef(claimTileSize);
   claimRef.current = claimTileSize;
+  // Set by the watch effect so an explicit claim can chase the new size.
+  const settleRef = useRef<((attempt: number) => void) | null>(null);
 
   // Watch mode: full-screen repaints from the daemon grid. One request, one
   // parse pass (RIS + serialized screen), no flicker — the same bytes the
@@ -849,10 +852,11 @@ const LiveTile = ({ wsBase, room, userName, theme, live, claudeApp, claimSize, a
         });
       } catch { /* keep the last frame */ }
     };
-    // Claim first, then CHASE it: poll the grid on a fast schedule until it
-    // reports the claimed dims (the PTY resize → app redraw → grid ingest
-    // pipeline takes a few hundred ms). One straggling 5s poll slot per tile
-    // is what made refits look one-by-one.
+    // CHASE a claim: poll the grid on a fast schedule until it reports the
+    // claimed dims (the PTY resize → app redraw → grid ingest pipeline takes
+    // a few hundred ms). One straggling 5s poll slot per tile is what made
+    // refits look one-by-one. Only the ⤢ button claims from here now — a
+    // tile the user is merely looking at must not resize the session.
     const settle = (attempt: number) => {
       if (cancelled) return;
       const claimed = lastClaimRef.current;
@@ -862,23 +866,32 @@ const LiveTile = ({ wsBase, room, userName, theme, live, claudeApp, claimSize, a
       paint();
       if (attempt < 5) window.setTimeout(() => settle(attempt + 1), 200 + attempt * 250);
     };
-    claimRef.current(() => { settle(0); });
+    settleRef.current = settle;
     paint();
     const id = window.setInterval(paint, LIVETILE_POLL_MS);
-    // Tile geometry changes (zoom step, window resize) re-claim, debounced —
-    // "all session tiles autofit when the session view comes up and when
-    // resize happens".
+    // Tile geometry changes (zoom step, window resize) re-render this tile at
+    // the session's true grid, scaled. They used to re-CLAIM, which meant
+    // opening or resizing the wall silently resized every session on it —
+    // sessions ended up wearing the tile grid (121x32, 132x34) that nobody
+    // had ever typed in. The size follows what you act in, not what you look
+    // at; the ⤢ badge is how you hand a tile's shape to the session.
     let resizeDebounce = 0;
     const ro = typeof ResizeObserver !== "undefined"
       ? new ResizeObserver(() => {
           window.clearTimeout(resizeDebounce);
           resizeDebounce = window.setTimeout(() => {
-            if (!cancelled) claimRef.current(() => { settle(0); });
+            if (!cancelled) paint();
           }, 350);
         })
       : null;
     if (boxRef.current) ro?.observe(boxRef.current);
-    return () => { cancelled = true; window.clearInterval(id); window.clearTimeout(resizeDebounce); ro?.disconnect(); };
+    return () => {
+      cancelled = true;
+      settleRef.current = null;
+      window.clearInterval(id);
+      window.clearTimeout(resizeDebounce);
+      ro?.disconnect();
+    };
   }, [live, room]);
 
   // Live mode: the same terminal, now fed by the room's websocket. Size is
@@ -1166,7 +1179,7 @@ const LiveTile = ({ wsBase, room, userName, theme, live, claudeApp, claimSize, a
               onClick={(e) => {
                 e.stopPropagation();
                 panRef.current = null; // back to the automatic anchor
-                claimRef.current();
+                claimRef.current(() => settleRef.current?.(0));
               }}
             >
               <span className="offgrid-glyph" aria-hidden="true">⤢</span>
@@ -2452,11 +2465,16 @@ export const SessionSwitcher = ({
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ internalName: sessionKey(s), ...(target ? { target } : {}) })
       });
-      const data = await res.json().catch(() => ({} as { error?: string; name?: string; kind?: string; extract?: { turns?: number; bytes?: number } }));
+      const data = await res.json().catch(() => ({} as { error?: string; name?: string; internalName?: string; kind?: string; extract?: { turns?: number; bytes?: number } }));
       if (!res.ok) {
         onNotice(data.error || (target ? "Handoff failed" : "Fork failed"));
         return;
       }
+      // The new session belongs beside its source: the daemon files it in
+      // the same folder; on a hand-arranged wall it takes the next slot.
+      if (typeof data.internalName === "string" && data.internalName) {
+        persistManualOrder(insertAfter(manualOrder, sessionKey(s), data.internalName));
+      }
       if (data.kind === "handoff") {
         const kb = Math.max(1, Math.round((data.extract?.bytes || 0) / 1024));
         onNotice(`${data.name} — ${data.extract?.turns ?? "?"} turns handed off (${kb} KB); it reads them first`);

package/hay/apps/web/src/utils/sizeClaim.ts

@@ -0,0 +1,41 @@
+// Who may take a session's terminal size.
+//
+// The PTY has one size, shared by everyone looking at it, and it is sticky:
+// whatever was claimed last stays until someone claims again. So the rule is
+// deliberately narrow — only a surface the human just ACTED IN may take it.
+// Merely having a session on screen is not an act: a wall of tiles, a
+// background tab, a reconnect after a tunnel blip and a pane you are not
+// typing in all leave the size alone and render what they are given, scaled.
+
+export type ViewMode = "fit" | "full";
+export type Size = { cols: number; rows: number };
+
+/**
+ * An attach claims the size only when the human just opened THIS session
+ * here: a fresh page load, a switch, or closing the wall into it. A
+ * reconnect is the same socket healing itself, and a hidden tab is nobody
+ * looking, so neither claims.
+ *
+ * Manual view mode never auto-claims at all: its whole point is that the
+ * user sets the size themselves.
+ */
+export const claimOnAttach = (o: { viewMode: ViewMode; visible: boolean; deliberate: boolean }): boolean =>
+  o.viewMode === "fit" && o.visible && o.deliberate;
+
+/**
+ * A click inside the terminal is an act on this surface, so it may take the
+ * size — but only when that would actually change something. Already owning
+ * the session at this viewport's fit means a click is just a click, and must
+ * not push a resize (it would land on every selection drag).
+ */
+export const claimOnClick = (o: {
+  viewMode: ViewMode;
+  natural: Size | null;
+  active: Size | null;
+  owned: boolean;
+}): boolean => {
+  if (o.viewMode !== "fit" || !o.natural) return false;
+  if (!o.owned) return true;
+  if (!o.active) return true;
+  return o.active.cols !== o.natural.cols || o.active.rows !== o.natural.rows;
+};

package/hay/apps/web/src/utils/switcherModel.ts

@@ -266,6 +266,19 @@ const orderManually = (sessions: SwitcherSession[], manualOrder: string[]): Swit
   });
 };
 
+/**
+ * Place `key` right after `afterKey` in a manual order. A source the user
+ * never placed leaves the order alone: both then sort by name at the tail,
+ * where a fork's name already follows its source's.
+ */
+export const insertAfter = (order: string[], afterKey: string, key: string): string[] => {
+  const at = order.indexOf(afterKey);
+  if (at < 0 || afterKey === key) return order;
+  const without = order.filter((k) => k !== key);
+  const i = without.indexOf(afterKey);
+  return [...without.slice(0, i + 1), key, ...without.slice(i + 1)];
+};
+
 /**
  * Split sessions into the user's folders plus everything still loose.
  * Folders belong to MANUAL mode only: Recent is ordered by the machine and

package/hay/apps/web/test/sizeClaim.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { claimOnAttach, claimOnClick } from "../src/utils/sizeClaim";
+
+describe("claimOnAttach — only a deliberate open takes the size", () => {
+  const base = { viewMode: "fit" as const, visible: true, deliberate: true };
+  it("claims when the human opened this session here", () => {
+    expect(claimOnAttach(base)).toBe(true);
+  });
+  it("does not claim on a reconnect, in a hidden tab, or in Manual mode", () => {
+    expect(claimOnAttach({ ...base, deliberate: false })).toBe(false);
+    expect(claimOnAttach({ ...base, visible: false })).toBe(false);
+    expect(claimOnAttach({ ...base, viewMode: "full" })).toBe(false);
+  });
+});
+
+describe("claimOnClick — a click takes the size only when it changes something", () => {
+  const natural = { cols: 171, rows: 40 };
+  it("claims when someone else holds the size", () => {
+    expect(claimOnClick({ viewMode: "fit", natural, active: { cols: 56, rows: 32 }, owned: false })).toBe(true);
+  });
+  it("claims when we own a size that is no longer our fit", () => {
+    expect(claimOnClick({ viewMode: "fit", natural, active: { cols: 132, rows: 34 }, owned: true })).toBe(true);
+  });
+  it("stays quiet when the session is already at this viewport's fit", () => {
+    expect(claimOnClick({ viewMode: "fit", natural, active: { ...natural }, owned: true })).toBe(false);
+  });
+  it("never claims in Manual mode or before the terminal can be measured", () => {
+    expect(claimOnClick({ viewMode: "full", natural, active: null, owned: false })).toBe(false);
+    expect(claimOnClick({ viewMode: "fit", natural: null, active: null, owned: false })).toBe(false);
+  });
+});

package/hay/apps/web/test/switcherModel.test.ts

@@ -5,7 +5,8 @@ import {
   filterSessionsByOrigin,
   projectKey,
   relativeTime,
-  type SwitcherSession
+  type SwitcherSession,
+  insertAfter
 } from "../src/utils/switcherModel";
 
 const mk = (over: Partial<SwitcherSession> & { name: string }): SwitcherSession => ({
@@ -523,3 +524,15 @@ describe("origin scope vs foldered sessions", () => {
     expect(filterSessionsByOrigin(sessions, "agent").map((s) => s.name)).toContain("mybot");
   });
 });
+
+describe("insertAfter — a fork takes the slot after its source", () => {
+  it("inserts right after a placed source, moving an existing entry", () => {
+    expect(insertAfter(["a", "b", "c"], "a", "x")).toEqual(["a", "x", "b", "c"]);
+    expect(insertAfter(["a", "b", "x"], "a", "x")).toEqual(["a", "x", "b"]);
+  });
+  it("leaves the order alone when the source was never placed, or is itself", () => {
+    const order = ["a", "b"];
+    expect(insertAfter(order, "zzz", "x")).toBe(order);
+    expect(insertAfter(order, "a", "a")).toBe(order);
+  });
+});

package/hop

@@ -11769,18 +11769,24 @@ happens until someone clicks it.
                         saveDefinition: false,
                         command
                     });
+                    // Filed where its source is. The effective config is the
+                    // wall's own truth for the folder (saved, runtime and
+                    // durable layers merged); the durable meta alone missed
+                    // sessions filed before folders were written there.
+                    const folderId = config.folderId || meta?.folderId || null;
                     rememberRuntimeSessionMetadata(forkInternal, {
                         type: 'terminal',
                         displayName: forkName,
                         cwd,
                         createdBy,
-                        folderId: meta?.folderId || undefined
+                        folderId: folderId || undefined
                     });
                     writeClaudeSessionMeta(forkInternal, {
                         internalName: forkInternal,
                         displayName: forkName,
                         cwd,
                         createdBy,
+                        folderId: folderId || undefined,
                         forkedFrom: source,
                         ...(handoff ? { handoffFrom: sourceKind, handoffTo: wantTarget } : {})
                     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hop2",
-  "version": "0.11.53",
+  "version": "0.11.55",
   "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": {