hop2 0.11.70 → 0.11.71

package/hay/apps/server/src/hyperlinks.ts

@@ -0,0 +1,133 @@
+// OSC 8 hyperlinks survive the serialized attach snapshot.
+//
+// A room's attach replay is the headless grid serialized by xterm's
+// serialize addon, which carries colours and styles but not hyperlinks: a
+// cell's link id (OSC 8) is dropped. Codex prints its markdown links as a
+// TITLE with the URL riding underneath, so once a client attached — the
+// usual way of reading a session — every link already on screen was plain
+// text: "codex tile links are not clickable". Live output after the attach
+// still carried them, which is why it looked intermittent.
+//
+// Rather than fork the addon, the serialized string is walked in step with
+// the buffer it came from. The addon's emission is regular: per row, each
+// cell of width > 0 either appends its characters or, when empty, is counted
+// and later skipped with `ESC[nC` (after an optional `ESC[nX`); rows end
+// with `\r\n`, or nothing when the next row is a wrap; width-0 cells (the
+// second half of a wide char) are not emitted. So printable text maps onto
+// cells one by one, and a link run can be wrapped where its first cell is
+// consumed and closed where it ends. Any desync (a cell whose characters are
+// not what the string says next) returns the original string unchanged — a
+// snapshot without links beats a corrupted one.
+
+export type LinkCell = { chars: string; width: number; urlId: number };
+
+export type InjectOptions = {
+  /** Cell at (buffer row, col) — null past the end. */
+  getCell: (row: number, col: number) => LinkCell | null;
+  cols: number;
+  /** First buffer row the serialized string covers. */
+  startRow: number;
+  /** Number of buffer rows it covers. */
+  rowCount: number;
+  /** The link target for a cell's link id, if any. */
+  uriOf: (urlId: number) => string | undefined;
+};
+
+const ESC = "\x1b";
+const BEL = "\x07";
+
+/** Length of the escape sequence starting at `i` (which is ESC). */
+const escapeLength = (s: string, i: number): number => {
+  const next = s[i + 1];
+  if (next === "[") {
+    let j = i + 2;
+    while (j < s.length) {
+      const c = s.charCodeAt(j);
+      if (c >= 0x40 && c <= 0x7e) return j + 1 - i;
+      j++;
+    }
+    return s.length - i;
+  }
+  if (next === "]") {
+    const bel = s.indexOf(BEL, i + 2);
+    const st = s.indexOf(ESC + "\\", i + 2);
+    const end = bel === -1 ? st : st === -1 ? bel : Math.min(bel, st);
+    if (end === -1) return s.length - i;
+    return end + (s[end] === BEL ? 1 : 2) - i;
+  }
+  return Math.min(2, s.length - i);
+};
+
+/** `ESC[nC` → n, else 0. */
+const cursorForward = (seq: string): number => {
+  const m = /^\x1b\[(\d*)C$/.exec(seq);
+  return m ? Math.max(1, Number(m[1] || 1)) : 0;
+};
+
+export const injectHyperlinks = (serialized: string, o: InjectOptions): string => {
+  const endRow = o.startRow + o.rowCount; // exclusive
+  let row = o.startRow;
+  let col = 0;
+  let out = "";
+  let openId = 0;
+  const open = (id: number): boolean => {
+    const uri = o.uriOf(id);
+    if (!uri) return false;
+    out += `${ESC}]8;id=hop${id};${uri}${ESC}\\`;
+    openId = id;
+    return true;
+  };
+  const close = () => {
+    if (openId) out += `${ESC}]8;;${ESC}\\`;
+    openId = 0;
+  };
+  // The content cell at the cursor, skipping the placeholders a wide char
+  // leaves behind. Null past the row's end.
+  const contentCell = (): LinkCell | null => {
+    while (col < o.cols) {
+      const cell = o.getCell(row, col);
+      if (!cell) return null;
+      if (cell.width > 0) return cell;
+      col++;
+    }
+    return null;
+  };
+  let i = 0;
+  while (i < serialized.length) {
+    const ch = serialized[i];
+    if (ch === ESC) {
+      const n = escapeLength(serialized, i);
+      const seq = serialized.slice(i, i + n);
+      // A link is a property of the characters written while it is open;
+      // cursor moves and erases must not carry it, so close across them.
+      // Styling (SGR) inside a run is fine: the id keeps the run one link.
+      if (!/m$/.test(seq)) close();
+      const fwd = cursorForward(seq);
+      if (fwd && row < endRow) col = Math.min(o.cols, col + fwd);
+      out += seq;
+      i += n;
+      continue;
+    }
+    if (ch === "\r" || ch === "\n") {
+      close();
+      out += ch;
+      if (ch === "\n") { row++; col = 0; }
+      i++;
+      continue;
+    }
+    // Printable: the next content cell.
+    if (row >= endRow) { close(); out += serialized.slice(i); return out; }
+    if (col >= o.cols) { row++; col = 0; } // a wrapped row ran straight on
+    const cell = contentCell();
+    if (!cell || !cell.chars || !serialized.startsWith(cell.chars, i)) return serialized;
+    if (cell.urlId !== openId) {
+      close();
+      if (cell.urlId) open(cell.urlId);
+    }
+    out += cell.chars;
+    i += cell.chars.length;
+    col += cell.width;
+  }
+  close();
+  return out;
+};

package/hay/apps/server/src/lib.ts

@@ -1,7 +1,7 @@
 // Termshare Server Library
 // Export everything needed for embedding into other apps
 
-export { Room, RoomManager, type SocketAdapter, type ClientInfo, type RoomSummary } from "./rooms";
+export { Room, RoomManager, setDefaultViewerColors, getDefaultViewerColors, type SocketAdapter, type ClientInfo, type RoomSummary } from "./rooms";
 export { createPty, type PtyFactory } from "./pty";
 export { sanitizeName, sanitizeRoom } from "./utils";
 

package/hay/apps/server/src/rooms.ts

@@ -87,6 +87,27 @@ export type ClientInfo = {
   nudge?: boolean;
 };
 
+// The colors of the LAST viewer anyone had, host-wide. A room usually
+// starts headless — the daemon creates it, the app launches and asks "what's
+// your background?" within milliseconds, and the browser attaches only
+// after — so a per-room memory of "its own last viewer" is empty exactly
+// when it is needed. Codex and Claude pick light vs dark from this answer
+// ONCE, at startup: told the dark default, Codex drew a charcoal composer
+// box on the user's white theme for the rest of the session. The newest
+// viewer's colors are what the user is looking at; every new room answers
+// with them until a viewer of its own says otherwise. Persisted by the host
+// so a restart (restore, keeper re-adoption) keeps the answer.
+const viewerColors = { bg: "0d1117", fg: "e6edf3" };
+const HEX6 = /^[0-9a-f]{6}$/i;
+/** Remember the viewer's colors for every room created from now on. Returns true when they changed. */
+export function setDefaultViewerColors(bg?: string | null, fg?: string | null): boolean {
+  let changed = false;
+  if (bg && HEX6.test(bg) && bg.toLowerCase() !== viewerColors.bg) { viewerColors.bg = bg.toLowerCase(); changed = true; }
+  if (fg && HEX6.test(fg) && fg.toLowerCase() !== viewerColors.fg) { viewerColors.fg = fg.toLowerCase(); changed = true; }
+  return changed;
+}
+export const getDefaultViewerColors = () => ({ ...viewerColors });
+
 export type RoomCreateOptions = {
   cwd: string;
   env?: Record<string, string>;
@@ -286,9 +307,9 @@ export class Room extends EventEmitter {
   // getOutputSince hand out stable cursors into an ever-trimming ring.
   private outputStart = 0;
   // Last viewer's terminal colors (6-hex, no '#'), used to answer OSC 10/11
-  // while headless. Defaults to the web client's dark surface.
-  private clientBg = "0d1117";
-  private clientFg = "e6edf3";
+  // while headless. Starts as the host-wide last viewer's (see viewerColors).
+  private clientBg = viewerColors.bg;
+  private clientFg = viewerColors.fg;
   private alternateScreen = false;
   // Enhanced keyboard reporting requested by the remote app (kitty keyboard protocol
   // or xterm modifyOtherKeys). Tracked like alternateScreen so a reattaching client
@@ -1364,8 +1385,9 @@ export class Room extends EventEmitter {
    */
   /** Remember the viewer's terminal colors for headless OSC 10/11 answers. */
   setClientColors(bg?: string | null, fg?: string | null) {
-    if (bg && /^[0-9a-f]{6}$/i.test(bg)) this.clientBg = bg.toLowerCase();
-    if (fg && /^[0-9a-f]{6}$/i.test(fg)) this.clientFg = fg.toLowerCase();
+    if (bg && HEX6.test(bg)) this.clientBg = bg.toLowerCase();
+    if (fg && HEX6.test(fg)) this.clientFg = fg.toLowerCase();
+    setDefaultViewerColors(bg, fg);
   }
 
   getOutputSince(

package/hay/apps/server/src/screenGrid.ts

@@ -16,7 +16,15 @@
 // room silently falls back to the raw-tail snapshot (+ wiggle), so a broken
 // dependency degrades to the old behavior instead of breaking attach.
 
+import { injectHyperlinks } from "./hyperlinks";
+
+type HeadlessCell = { getChars(): string; getWidth(): number; extended?: { urlId?: number } };
 type HeadlessTerminal = {
+  rows?: number;
+  cols?: number;
+  buffer?: { active: { length: number; getLine(y: number): { getCell(x: number): HeadlessCell | undefined } | undefined } };
+  // Internals the serialize addon drops (OSC 8 targets); read guardedly.
+  _core?: { _oscLinkService?: { getLinkData(id: number): { uri?: string } | undefined; _dataByLinkId?: Map<number, unknown> } };
   write(data: string, callback?: () => void): void;
   resize(cols: number, rows: number): void;
   loadAddon(addon: unknown): void;
@@ -96,6 +104,26 @@ export type ScreenGrid = {
   dispose(): void;
 };
 
+// The serialize addon drops OSC 8 hyperlinks; put them back from the
+// buffer's own link ids (see hyperlinks.ts). Skipped outright when the grid
+// has registered no link at all — the common case, at no cost.
+const withHyperlinks = (term: HeadlessTerminal, serialized: string, scrollback: number): string => {
+  try {
+    const svc = term._core?._oscLinkService;
+    const buf = term.buffer?.active;
+    if (!svc || !buf || !term.rows) return serialized;
+    if (svc._dataByLinkId && svc._dataByLinkId.size === 0) return serialized;
+    const rowCount = Math.min(buf.length, scrollback + term.rows);
+    return injectHyperlinks(serialized, {
+      cols: term.cols ?? 0, startRow: buf.length - rowCount, rowCount,
+      getCell: (y, x) => { const c = buf.getLine(y)?.getCell(x); return c ? { chars: c.getChars(), width: c.getWidth(), urlId: c.extended?.urlId || 0 } : null; },
+      uriOf: (id) => svc.getLinkData(id)?.uri
+    });
+  } catch {
+    return serialized;
+  }
+};
+
 export const createScreenGrid = (cols: number, rows: number): ScreenGrid | null => {
   if (!deps) return null;
   let term: HeadlessTerminal;
@@ -165,7 +193,8 @@ export const createScreenGrid = (cols: number, rows: number): ScreenGrid | null
         term.write("", () => {
           if (disposed) { callback(null); return; }
           try {
-            callback(addon.serialize({ scrollback: Math.max(0, Math.min(scrollback, GRID_SCROLLBACK)) }));
+            const sb = Math.max(0, Math.min(scrollback, GRID_SCROLLBACK));
+            callback(withHyperlinks(term, addon.serialize({ scrollback: sb }), sb));
           } catch {
             callback(null);
           }

package/hay/apps/server/test/hyperlinks.test.ts

@@ -0,0 +1,99 @@
+// OSC 8 links survive a serialize → inject → replay round trip through real
+// xterm: the replayed terminal's cells carry the same targets, and its text
+// is the serialized terminal's text.
+import { describe, expect, it } from "vitest";
+import { injectHyperlinks } from "../src/hyperlinks";
+
+type Cell = { getChars(): string; getWidth(): number; extended?: { urlId?: number } };
+type Term = {
+  rows: number; cols: number;
+  buffer: { active: { length: number; getLine(y: number): { getCell(x: number): Cell | undefined; translateToString(trim?: boolean): string } | undefined } };
+  write(d: string, cb?: () => void): void;
+  loadAddon(a: unknown): void;
+  _core: { _oscLinkService: { getLinkData(id: number): { uri: string } | undefined } };
+};
+
+const g = globalThis as Record<string, unknown>;
+if (!g.window) g.window = g;
+if (!g.self) g.self = g;
+
+const make = async (cols = 40, rows = 6, scrollback = 100) => {
+  // UMD/CJS under ESM interop: the named exports may live on `default`
+  // (screenGrid.ts resolves them the same way).
+  const h = await import("@xterm/headless") as { Terminal?: unknown; default?: { Terminal?: unknown } };
+  const sz = await import("@xterm/addon-serialize") as { SerializeAddon?: unknown; default?: { SerializeAddon?: unknown } };
+  const Terminal = (h.Terminal ?? h.default?.Terminal) as new (o: Record<string, unknown>) => Term;
+  const SerializeAddon = (sz.SerializeAddon ?? sz.default?.SerializeAddon) as new () => { serialize(o: { scrollback?: number }): string };
+  const term = new Terminal({ cols, rows, scrollback, allowProposedApi: true });
+  const addon = new SerializeAddon();
+  term.loadAddon(addon);
+  const write = (d: string) => new Promise<void>((r) => term.write(d, r));
+  const serialize = (sb = scrollback) => {
+    const s = addon.serialize({ scrollback: sb });
+    const buf = term.buffer.active;
+    const rowCount = Math.min(buf.length, sb + term.rows);
+    return injectHyperlinks(s, {
+      cols: term.cols, startRow: buf.length - rowCount, rowCount,
+      getCell: (y, x) => { const c = buf.getLine(y)?.getCell(x); return c ? { chars: c.getChars(), width: c.getWidth(), urlId: c.extended?.urlId || 0 } : null; },
+      uriOf: (id) => term._core._oscLinkService.getLinkData(id)?.uri
+    });
+  };
+  return { term, write, serialize };
+};
+
+const linksOf = (term: Term) => {
+  const buf = term.buffer.active;
+  const out: { row: number; text: string; uri: string }[] = [];
+  for (let y = 0; y < buf.length; y++) {
+    const line = buf.getLine(y)!;
+    let cur: { row: number; text: string; uri: string } | null = null;
+    for (let x = 0; x < term.cols; x++) {
+      const c = line.getCell(x)!;
+      const uri = c.extended?.urlId ? term._core._oscLinkService.getLinkData(c.extended.urlId)?.uri || "" : "";
+      if (uri && cur && cur.uri === uri) cur.text += c.getChars();
+      else if (uri) { cur = { row: y, text: c.getChars(), uri }; out.push(cur); }
+      else cur = null;
+    }
+  }
+  return out;
+};
+const textOf = (term: Term) => Array.from({ length: term.buffer.active.length }, (_, y) => term.buffer.active.getLine(y)!.translateToString(true)).join("\n").replace(/\n+$/, "");
+
+const L = (uri: string, text: string) => `\x1b]8;;${uri}\x07${text}\x1b]8;;\x07`;
+
+describe("injectHyperlinks — OSC 8 links ride the serialized snapshot", () => {
+  it("a titled link (Codex's markdown link) comes back as a link, text intact", async () => {
+    const a = await make(80);
+    await a.write(`• Wrote the plan: ${L("https://hop.zhoulab.io/view/s_1/plan.html/inline", "proposed next experiments")}.\r\nnext line\r\n`);
+    const b = await make(80);
+    await b.write(a.serialize());
+    expect(textOf(b.term)).toBe(textOf(a.term));
+    expect(linksOf(b.term)).toEqual([{ row: 0, text: "proposed next experiments", uri: "https://hop.zhoulab.io/view/s_1/plan.html/inline" }]);
+  });
+
+  it("colours inside a link, empty gaps, wide characters and a wrapped row all keep their places", async () => {
+    const a = await make(20, 5);
+    await a.write(`\x1b[31mred\x1b[0m   ${L("https://x.test/a", "li\x1b[1mnk\x1b[22m 漢字")}  tail\r\n`);
+    await a.write(`${L("https://x.test/b", "0123456789abcdefghijKLMNOP")}\r\n`); // wraps at 20
+    await a.write(`gap ${L("https://x.test/c", "c")}\x1b[5C${L("https://x.test/d", "d")}\r\n`);
+    const b = await make(20, 5);
+    await b.write(a.serialize());
+    expect(textOf(b.term)).toBe(textOf(a.term));
+    expect(linksOf(b.term)).toEqual(linksOf(a.term));
+    expect(linksOf(b.term).map((l) => l.text)).toEqual(["link 漢字", "0123456789abcdefghij", "KLMNOP", "c", "d"]);
+  });
+
+  it("a snapshot with scrollback trimmed off keeps the links of the rows it covers", async () => {
+    const a = await make(30, 3, 50);
+    for (let i = 0; i < 8; i++) await a.write(`${L(`https://x.test/${i}`, `line ${i}`)}\r\n`);
+    const b = await make(30, 3, 50);
+    await b.write(a.serialize(2)); // 2 rows of history + 3 of screen
+    expect(linksOf(b.term).map((l) => l.uri)).toEqual(["https://x.test/4", "https://x.test/5", "https://x.test/6", "https://x.test/7"]);
+  });
+
+  it("a desync returns the string untouched rather than a corrupted screen", () => {
+    const s = "\x1b[31mhello\x1b[0m";
+    const out = injectHyperlinks(s, { cols: 10, startRow: 0, rowCount: 1, getCell: () => ({ chars: "x", width: 1, urlId: 1 }), uriOf: () => "https://x" });
+    expect(out).toBe(s);
+  });
+});

package/hay/apps/server/test/rooms.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it, vi } from "vitest";
-import { RoomManager } from "../src/rooms";
+import { RoomManager, getDefaultViewerColors, setDefaultViewerColors } from "../src/rooms";
 import type { PtyFactory } from "../src/pty";
 
 type Message = { type: string; [key: string]: unknown };
@@ -766,6 +766,28 @@ describe("Room", () => {
       const factory: PtyFactory = () => {
         ptyInstance = new FakePty() as unknown as FakePty;
         return ptyInstance as any;
+
+    it("a NEW headless room answers with the colors the last viewer (of any room) had — a light theme stays light", () => {
+      const ptys: FakePty[] = [];
+      const factory: PtyFactory = () => { const p = new FakePty(); ptys.push(p); return p as any; };
+      const manager = new RoomManager(factory);
+      const first = manager.getRoom("seen", { cols: 80, rows: 24 }, "/tmp");
+      // The browser attached on a white theme (its bg/fg ride on the attach URL).
+      first.setClientColors("ffffff", "1f2328");
+      expect(getDefaultViewerColors()).toEqual({ bg: "ffffff", fg: "1f2328" });
+
+      // The next room is created by the daemon and probed by Codex before any
+      // browser attaches: it is told white, not the dark default.
+      manager.getRoom("fresh", { cols: 80, rows: 24 }, "/tmp");
+      ptys[1].emit("\x1b]10;?\x07\x1b]11;?\x1b\\");
+      const answered = ptys[1].writes.join("");
+      expect(answered).toContain("]11;rgb:ffff/ffff/ffff");
+      expect(answered).toContain("]10;rgb:1f1f/2323/2828");
+
+      // Garbage never replaces a good answer; the dark default is restorable.
+      expect(setDefaultViewerColors("#fff", "nope")).toBe(false);
+      expect(setDefaultViewerColors("0d1117", "e6edf3")).toBe(true);
+    });
       };
       const manager = new RoomManager(factory);
       const room = manager.getRoom(roomId, initialSize, "/tmp");

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

@@ -16,7 +16,7 @@ import { collectTerminalMatches, selectTerminalMatch } from "./utils/terminalSea
 import { createVoiceHold, speechRecognitionCtor } from "./utils/voiceHold";
 import { tabTitle } from "./utils/tabTitle";
 import { remoteAppOwnsScreen } from "./utils/echoGuard";
-import { urlAtCell, cellAtPoint } from "./utils/urlAtCell";
+import { urlAtCell, cellAtPoint, oscUrlAtCell } from "./utils/urlAtCell";
 import { enableMathHover } from "./utils/mathLinkProvider";
 import { getMathTip } from "./utils/mathTooltip";
 import { scanKeyboardProtocol } from "./utils/keyboardProtocol";
@@ -2147,6 +2147,15 @@ const App = () => {
       scrollSensitivity: 4,
       fastScrollSensitivity: 12,
       minimumContrastRatio: contrastFloorFor(themeMode),
+      // OSC 8 hyperlinks — Codex prints a markdown link as its title with the
+      // URL underneath. xterm's default for these is a confirm() dialog;
+      // open them like the addon's links instead.
+      linkHandler: {
+        activate: (event, uri) => {
+          event.preventDefault();
+          window.open(uri, "_blank", "noopener");
+        }
+      },
       theme: resolveTerminalTheme(themeMode)
     });
     const fitAddon = new FitAddon();
@@ -3866,7 +3875,7 @@ const App = () => {
     return urlAtCell(
       (i) => { const l = buf.getLine(i); return l ? { text: l.translateToString(false), wrapped: l.isWrapped } : null; },
       buf.length, term.cols, bufferRow, col
-    );
+    ) || oscUrlAtCell(term, bufferRow, col);
   }, []);
 
   // Enroll this device's platform authenticator (Touch ID / Face ID) as a

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

@@ -19,7 +19,7 @@ import { claimOnTileFocus, sizeIsForeign } from "../utils/sizeClaim";
 import { cardPhase, phaseLabel, phaseTitle } from "../utils/agentPhase";
 import { installDragSelect } from "../utils/dragSelect";
 import { enableViewBlocks } from "../utils/viewBlocks";
-import { urlAtCell, cellAtPoint } from "../utils/urlAtCell";
+import { urlAtCell, cellAtPoint, oscUrlAtCell } from "../utils/urlAtCell";
 import { attachScrollFlywheel } from "../utils/scrollFlywheel";
 import { ContextMenu, type MenuRequest } from "./ContextMenu";
 import { CwdField } from "./CwdField";
@@ -396,10 +396,12 @@ const LiveTile = ({ wsBase, room, userName, theme, live, deliberate, claudeApp,
     const rowsEl = boxRef.current?.querySelector(".xterm-rows") as HTMLElement | null;
     const cell = cellAtPoint(screen, rowsEl, term.cols, term.rows, clientX, clientY);
     const buf = term.buffer.active;
-    const url = cell ? urlAtCell(
+    // A URL in the text, reassembled across rows — or the OSC 8 target a
+    // TUI hung on a title (Codex's markdown links), which has no URL text.
+    const url = cell ? (urlAtCell(
       (i) => { const l = buf.getLine(i); return l ? { text: l.translateToString(false), wrapped: l.isWrapped } : null; },
       buf.length, term.cols, buf.viewportY + cell.row, cell.col
-    ) : null;
+    ) || oscUrlAtCell(term, buf.viewportY + cell.row, cell.col)) : null;
     // Diagnostics for "clicking a link in a tile does nothing" reports:
     // localStorage.hay_debug_links=1 prints what the click resolved to.
     try {
@@ -525,6 +527,16 @@ const LiveTile = ({ wsBase, room, userName, theme, live, deliberate, claudeApp,
       fontFamily: monoStack,
       cursorBlink: false,
       disableStdin: true,
+      // OSC 8 hyperlinks (Codex's markdown links show a title, the URL rides
+      // underneath): without a handler xterm throws up a confirm() dialog,
+      // which read as "the link does nothing". Open it like any other link.
+      linkHandler: {
+        activate: (event, uri) => {
+          event.preventDefault();
+          lastLinkOpenAtRef.current = Date.now();
+          window.open(uri, "_blank", "noopener");
+        }
+      },
       theme: theme as never
     });
     const fit = new FitAddon();

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

@@ -12,6 +12,32 @@
 
 export type CellLine = { text: string; wrapped: boolean };
 
+/**
+ * The OSC 8 hyperlink under a cell, if the app printed one. Codex renders a
+ * markdown link as its TITLE text carrying the URL as an OSC 8 target —
+ * "proposed next experiments" on screen, the hop view URL underneath — so
+ * there is no URL text for the regex-based addon or urlAtCell to find.
+ * xterm keeps the target on the cell (its link id) and in its link service;
+ * neither is public API, so this reads them guardedly and returns null on
+ * any other xterm. http(s) only: a file:// or custom-scheme target is not
+ * something a click in a browser can open.
+ */
+export const oscUrlAtCell = (term: unknown, bufferRow: number, col: number): string | null => {
+  try {
+    const t = term as {
+      buffer: { active: { getLine: (r: number) => { getCell: (c: number) => unknown } | undefined } };
+      _core?: { _oscLinkService?: { getLinkData: (id: number) => { uri?: string } | undefined } };
+    };
+    const cell = t.buffer.active.getLine(bufferRow)?.getCell(col) as { extended?: { urlId?: number } } | undefined;
+    const id = cell?.extended?.urlId;
+    if (!id) return null;
+    const uri = t._core?._oscLinkService?.getLinkData(id)?.uri;
+    return uri && /^https?:\/\//i.test(uri) ? uri : null;
+  } catch {
+    return null;
+  }
+};
+
 /**
  * The (row, col) under a viewport point. With the DOM renderer each row is
  * an element, so the row comes from whichever one contains the point —

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

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { urlAtCell } from "../src/utils/urlAtCell";
+import { oscUrlAtCell, urlAtCell } from "../src/utils/urlAtCell";
 
 const COLS = 42;
 const pad = (s: string) => s.padEnd(COLS, " ");
@@ -48,3 +48,20 @@ describe("urlAtCell", () => {
     expect(urlAtCell(b.get, b.length, COLS, 0, 3)).toBeNull();
   });
 });
+
+describe("oscUrlAtCell — the OSC 8 target under a title (Codex's markdown links)", () => {
+  const fakeTerm = (urlId: number | undefined, uri: string | undefined) => ({
+    buffer: { active: { getLine: (r: number) => (r === 3 ? { getCell: (c: number) => (c === 5 ? { extended: { urlId } } : {}) } : undefined) } },
+    _core: { _oscLinkService: { getLinkData: (id: number) => (id === 7 ? { uri } : undefined) } }
+  });
+  it("resolves the link's URL from the cell's link id", () => {
+    expect(oscUrlAtCell(fakeTerm(7, "https://hop.zhoulab.io/view/s_1/plan.html/inline"), 3, 5)).toBe("https://hop.zhoulab.io/view/s_1/plan.html/inline");
+  });
+  it("nothing for a plain cell, another row, a non-http target, or an xterm without the internals", () => {
+    expect(oscUrlAtCell(fakeTerm(7, "https://x.test/"), 3, 6)).toBeNull();
+    expect(oscUrlAtCell(fakeTerm(7, "https://x.test/"), 2, 5)).toBeNull();
+    expect(oscUrlAtCell(fakeTerm(undefined, "https://x.test/"), 3, 5)).toBeNull();
+    expect(oscUrlAtCell(fakeTerm(7, "file:///etc/hosts"), 3, 5)).toBeNull();
+    expect(oscUrlAtCell({ buffer: { active: { getLine: () => ({ getCell: () => ({ extended: { urlId: 7 } }) }) } } }, 3, 5)).toBeNull();
+  });
+});

package/hop

@@ -4788,7 +4788,7 @@ function buildSessionEntries(haySessions, opts = {}) {
             createdAt: config?.createdAt,
             createdBy: effective?.createdBy || 'user',
             agentPermitted: config?.agentPermitted === true,
-            agent: sessionAgentKind(s.name),
+            agent: sessionAgentKind(name),
             localCliCount: clientSummary.localCliCount,
             hasLocalCli: clientSummary.hasLocalCli,
             ...getSessionSeenInfo(name)
@@ -17967,7 +17967,7 @@ async function main() {
         }
         // Name the session it was filed under, so a wrong one is visible at
         // once (an inherited HOP_SESSION can belong to another session).
-        console.log(`Filed under ${getSessionDisplayName(session) || session}${wantSession ? '' : ' (from HOP_SESSION; pass --session <name> to file elsewhere)'}.`);
+        console.log(`Filed under ${getSessionDisplayName(caller) || caller}.`);
         // Same one-bell convention as `hop view` — the human is usually
         // waiting on this, and the link scrolls away unannounced otherwise.
         process.stdout.write('\x07');

package/package.json

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

package/scripts/hay-host.js

@@ -80,6 +80,21 @@ if (HOP_HOME.startsWith(os.tmpdir())) {
   }, 30000).unref();
 }
 const BUFFER_DIR = path.join(HOP_HOME, 'session-buffers');
+// The last viewer's terminal colors, kept across host restarts: a room that
+// starts headless answers an app's "what's your background?" (OSC 10/11)
+// with these, so Codex/Claude theme themselves light or dark to match what
+// the user actually looks at — restored rooms included.
+const VIEWER_COLORS_FILE = path.join(HOP_HOME, '.hay-viewer-colors');
+function loadViewerColors(hay) {
+    try {
+        const saved = JSON.parse(fs.readFileSync(VIEWER_COLORS_FILE, 'utf8'));
+        if (typeof hay.setDefaultViewerColors === 'function') hay.setDefaultViewerColors(saved.bg, saved.fg);
+    } catch (e) { /* none yet: the dark default */ }
+}
+function rememberViewerColors(hay, bg, fg) {
+    if (typeof hay.setDefaultViewerColors !== 'function') return;
+    if (!hay.setDefaultViewerColors(bg, fg)) return;
+    try { fs.writeFileSync(VIEWER_COLORS_FILE, JSON.stringify(hay.getDefaultViewerColors())); } catch (e) { /* best effort */ }
 const CLAUDE_SESSIONS_DIR = path.join(HOP_HOME, 'claude-sessions');
 
 // Scrub Claude Code SESSION markers from our environment before any PTY is
@@ -220,6 +235,7 @@ function normalizeEnv(rawEnv) {
 async function main() {
     const libPath = path.join(__dirname, '..', 'hay', 'apps', 'server', 'dist', 'lib.js');
     const hay = await import(pathToFileURL(libPath));
+    loadViewerColors(hay);
     const rooms = new hay.RoomManager(hay.createPty);
     const server = http.createServer(async (req, res) => {
         const reqUrl = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
@@ -439,6 +455,7 @@ async function main() {
         const clientFg = hex(wsUrl.searchParams.get('fg'));
         if (clientBg && typeof room.setClientColors === 'function') {
             room.setClientColors(clientBg, clientFg);
+            rememberViewerColors(hay, clientBg, clientFg);
         }
         // Tab identity forwarded by the daemon: the room evicts a same-key
         // predecessor on attach, so a phone's reconnect replaces its own