Disarm stale URL handlers, match uppercase schemes, hedge OSC-8 docs

A retext that dropped the last URL left the old hit ranges armed, so Ctrl+clicking the old columns still opened. The armer now clears its handlers when no line holds a URL.

Author: TheGreatAxios

docs/TUI.md

@@ -823,12 +823,17 @@ running its own selection. Two chords cover remaining copy needs:
   `http(s)` URL in a plain or structured-text transcript row underlines it;
   pressing and releasing on the same URL opens it in the default browser,
   while a press that releases anywhere else stays a selection gesture:
-  - **macOS: Cmd+click.** The terminal itself owns this chord: every link
-    span carries OSC-8 metadata, so the emulator opens the URL and the app
-    never sees the press.
+  - **macOS: Cmd+click.** The terminal itself owns this chord: link spans
+    carry OSC-8 metadata, so an emulator with OSC-8 support opens the URL
+    and the app never sees the press. Per-terminal: Terminal.app does not
+    support OSC-8, so Cmd+click does nothing there; iTerm2 3.5+, Ghostty,
+    WezTerm, Kitty, and VS Code support it.
   - **Linux/Windows: Ctrl+click.** The app opens the URL through the
     platform opener (`open` on macOS as fallback, `xdg-open`, `cmd /c
 start`).
+  - **Right-click safety.** The open gesture requires a left (button-0)
+    press with the modifier held, so Ctrl+right-click never opens a URL —
+    context menus stay safe.
   - Without the modifier, nothing changes: clicks still expand rows and
     drags still select-and-copy. With mouse capture off (Alt+M), the
     terminal owns every click and the app sees none, so there is nothing to
@@ -915,7 +920,8 @@ terminal. It cannot observe:
   and headless suites pin the gating (Ctrl+press opens, plain click and
   Ctrl+drag do not, non-`http(s)` never opens) with a mocked opener, but
   only a real terminal can show whether it delivers the held Ctrl on motion
-  and press events, or resolves the `open`/`xdg-open` spawn into a browser.
+  and press events, whether it honors OSC-8 for Cmd+click, or resolves the
+  `open`/`xdg-open` spawn into a browser.
 - **The system clipboard.** `system-clipboard.ts`'s helper-binary spawns and
   OSC 52 fallback are exercised with mocked spawn functions in tests; no
   test round-trips through a real `pbcopy`/`xclip`/terminal clipboard.

src/tui/shell/transcript.ts

@@ -13,6 +13,7 @@ import {
 import { stringWidth } from "../view/height.js";
 import { viewToTableContent, type McpStructuredView } from "../mcp-view.js";
 import {
+  armLinkLine,
   buildLinkLine,
   findLinks,
   paintLinkLine,
@@ -407,6 +408,9 @@ function paintPlainRowNode(
   if (!lines.some((line) => findLinks(line).length > 0)) {
     node.content = painted.content;
     node.fg = painted.fg;
+    // Route through the armer so a retext that drops the last URL disarms
+    // the handlers a previous arming installed (armLinkLine clears them).
+    armLinkLine(node, []);
     return;
   }
   paintLinkLine(

src/tui/url-click.test.ts

@@ -7,12 +7,19 @@
  * spot (docs/TUI.md); headless, the mock delivers it like any click.
  */
 import { describe, expect, test } from "bun:test";
+import { TextRenderable } from "@opentui/core";
 
 import { defined } from "../../tests/helpers/defined.js";
 import { withTestRenderer } from "./harness";
 import { appendStreamRow } from "./shell/chrome";
 import { createAppShell } from "./shell/index";
-import { isUnderlined, resetUrlOpener, setUrlOpener } from "./url-links";
+import {
+  isUnderlined,
+  paintLinkLine,
+  resetUrlOpener,
+  setUrlOpener,
+  splitLinkSpans,
+} from "./url-links";
 import { type StreamRow } from "./stream";
 
 const CALL: StreamRow = {
@@ -123,4 +130,62 @@ describe("Ctrl+clicking a transcript URL", () => {
       { width: 80, height: 24 },
     );
   });
+
+  test("retexting the URL away disarms the node: old columns open nothing", async () => {
+    await withTestRenderer(
+      async (h) => {
+        const opened: string[] = [];
+        setUrlOpener((url) => {
+          opened.push(url);
+        });
+        try {
+          const line = "see https://example.com/x ok";
+          const node = new TextRenderable(h.renderer, { content: line });
+          h.root.add(node);
+          paintLinkLine(node, [splitLinkSpans([{ text: line, fg: "#fff" }])]);
+          await h.renderOnce();
+
+          const link = findCell(h.captureCharFrame(), "example.com");
+          expect(link).not.toBeNull();
+          const at = defined(link);
+
+          await h.mockMouse.click(at.x, at.y, 0, {
+            modifiers: { ctrl: true },
+          });
+          await h.renderOnce();
+          expect(opened).toEqual(["https://example.com/x"]);
+
+          // Retext the URL away, exactly as the row retext path does. The
+          // handlers are setter-only (no getter to assert on), so pin the
+          // disarm behaviorally: the old columns open nothing and hover
+          // leaves the painted text intact.
+          const retexted = "see nothing here";
+          paintLinkLine(node, [
+            splitLinkSpans([{ text: retexted, fg: "#fff" }]),
+          ]);
+          await h.renderOnce();
+          const frame = h.captureCharFrame();
+          expect(frame).toContain("nothing here");
+          expect(frame).not.toContain("example.com");
+
+          opened.length = 0;
+          await h.mockMouse.click(at.x, at.y, 0, {
+            modifiers: { ctrl: true },
+          });
+          await h.renderOnce();
+          expect(opened).toEqual([]);
+
+          const before = h.captureCharFrame();
+          await h.mockMouse.moveTo(at.x, at.y, {
+            modifiers: { ctrl: true },
+          });
+          await h.renderOnce();
+          expect(h.captureCharFrame()).toBe(before);
+        } finally {
+          resetUrlOpener();
+        }
+      },
+      { width: 80, height: 24 },
+    );
+  });
 });

src/tui/url-links.ts

@@ -41,7 +41,7 @@ interface LinkHit {
   readonly end: number;
 }
 
-const URL_PATTERN = /https?:\/\/[^\s<>"'`\]]+/g;
+const URL_PATTERN = /https?:\/\/[^\s<>"'`\]]+/gi;
 const TRAILING_PUNCTUATION = new Set([
   ".",
   ",",
@@ -296,9 +296,10 @@ function linkLinesChunks(
 /**
  * Arm a text node as a link hit target over caller-built per-line spans:
  * Ctrl+hover highlights the URL under the pointer, Ctrl+press and release on
- * the same URL opens it. A no-op when no line holds a URL, so URL-free nodes
- * carry no handlers at all; handler assignment replaces, so re-arming after
- * a retext never stacks.
+ * the same URL opens it. When no line holds a URL the node is disarmed — any
+ * handlers a previous arming installed are cleared — so a retext that drops
+ * the last URL leaves no stale hit target behind; handler assignment
+ * replaces, so re-arming after a retext never stacks.
  *
  * The press deliberately keeps bubbling — stopping it would break drag-select
  * starting on a URL — and the open fires on release only when the pointer
@@ -312,7 +313,14 @@ export function armLinkLine(
   lines: readonly (readonly LinkSpan[])[],
 ): void {
   const hits = lines.map(linkColumnHits);
-  if (!hits.some((line) => line.length > 0)) return;
+  if (!hits.some((line) => line.length > 0)) {
+    node.onMouseDown = undefined;
+    node.onMouseUp = undefined;
+    node.onMouseOver = undefined;
+    node.onMouseMove = undefined;
+    node.onMouseOut = undefined;
+    return;
+  }
   const at = (event: MouseEvent): string | null => {
     // Events carry terminal-absolute coordinates with no per-node transform,
     // so map through the node's own screen position (scroll-aware through the

tests/unit/tui/url-links.test.ts

@@ -80,6 +80,12 @@ describe("findLinks", () => {
       [],
     );
   });
+
+  test("matches uppercase schemes", () => {
+    expect(findLinks("see HTTP://EXAMPLE.COM/x ok").map((h) => h.url)).toEqual([
+      "HTTP://EXAMPLE.COM/x",
+    ]);
+  });
 });
 
 describe("splitLinkSpans", () => {
@@ -143,4 +149,13 @@ describe("openUrl", () => {
     });
     expect(() => openUrl("https://example.com")).not.toThrow();
   });
+
+  test("an uppercase URL round-trips through the opener", () => {
+    const calls: string[] = [];
+    setUrlOpener((url) => {
+      calls.push(url);
+    });
+    openUrl("HTTP://EXAMPLE.COM/x");
+    expect(calls).toEqual(["HTTP://EXAMPLE.COM/x"]);
+  });
 });