Open markdown transcript URLs with Ctrl+click

Assistant markdown paints through library renderables the app cannot
arm, so those links stayed terminal-owned. The renderer now exposes
getLinkAt link hit-testing (OpenTUI 0.5.11), so a bubbling
transcript-root handler can resolve markdown clicks and open them the
same way armed plain rows already do.

Author: TheGreatAxios

bun.lock

@@ -844,10 +844,12 @@ url.dll,FileProtocolHandler` — argv spawns, never through a shell).
     the existing capture; the pickers and setup screens stay opted out.
   - Wrapped URLs resolve whole: a URL broken across continuation lines
     highlights and opens as the one target from any of its fragments.
-  - Markdown prose (assistant messages) is not covered: the renderer paints
-    it through childless code renderers with no stable text-leaf API to
-    highlight or hit-test, so those links stay terminal business until the
-    library exposes one.
+  - Markdown prose (assistant messages) is click-to-open only: the renderer
+    paints it through childless code renderers with no node to arm, so there
+    is no hover underline. A bubbling handler on the transcript root resolves
+    the click through the renderer's `getLinkAt` link map (OpenTUI 0.5.11+)
+    and opens on press-and-release over the same URL — armed rows keep their
+    hover underline and open through their own node handlers.
 
 Arrow keys never scroll anything — inside the prompt they are caret motion
 or, at the buffer's edges, prompt-history recall; inside an open overlay's

docs/TUI.md

@@ -100,7 +100,7 @@
     "@intx/types": "workspace:*",
     "@intx/workflow-host": "0.3.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@opentui/core": "0.5.10",
+    "@opentui/core": "0.5.11",
     "arktype": "catalog:",
     "highlight.js": "^11.11.1",
     "isomorphic-git": "catalog:"
@@ -115,13 +115,13 @@
     "ws": "^8.21.0"
   },
   "optionalDependencies": {
-    "@opentui/core-darwin-arm64": "0.5.10",
-    "@opentui/core-darwin-x64": "0.5.10",
-    "@opentui/core-linux-arm64": "0.5.10",
-    "@opentui/core-linux-arm64-musl": "0.5.10",
-    "@opentui/core-linux-x64": "0.5.10",
-    "@opentui/core-linux-x64-musl": "0.5.10",
-    "@opentui/core-win32-arm64": "0.5.10",
-    "@opentui/core-win32-x64": "0.5.10"
+    "@opentui/core-darwin-arm64": "0.5.11",
+    "@opentui/core-darwin-x64": "0.5.11",
+    "@opentui/core-linux-arm64": "0.5.11",
+    "@opentui/core-linux-arm64-musl": "0.5.11",
+    "@opentui/core-linux-x64": "0.5.11",
+    "@opentui/core-linux-x64-musl": "0.5.11",
+    "@opentui/core-win32-arm64": "0.5.11",
+    "@opentui/core-win32-x64": "0.5.11"
   }
 }

package.json

@@ -72,6 +72,7 @@ import {
   submitPrompt,
   syncPromptHighlights,
 } from "./prompt.js";
+import { armMarkdownLinks } from "../url-links.js";
 import {
   createShellKeyHandlers,
   routePromptWheelToTranscript,
@@ -211,6 +212,10 @@ export function createAppShell(
   // every row to say so. Position is legible from the content itself.
   transcript.verticalScrollBar.visible = false;
   transcript.horizontalScrollBar.visible = false;
+  // Markdown blocks have no node of ours to arm; this bubbling handler is
+  // what makes their links Ctrl+click-to-open (armed rows stop propagation
+  // after opening, so a click opens exactly once either way).
+  armMarkdownLinks(transcript, ctx);
 
   // Leading filler that bottom-anchors a short transcript; see
   // `syncTranscriptSpacer`. Zero height until the first sync call.

src/tui/shell/index.ts

@@ -1,6 +1,9 @@
 /**
  * URL click-through (CL-7346): Ctrl+click opens an http(s) URL in the
- * default browser; a plain click keeps today's row behavior.
+ * default browser; a plain click keeps today's row behavior. Armed
+ * plain/structured rows open through their own node handlers (with hover
+ * highlight); assistant markdown opens through the bubbling transcript
+ * handler — click only, no hover highlight.
  *
  * The opener is mocked (setUrlOpener) — no test spawns a real browser.
  * Whether a real terminal reports the Ctrl modifier is a harness blind
@@ -339,7 +342,7 @@ describe("Ctrl+clicking a transcript URL", () => {
     );
   });
 
-  test("assistant markdown links stay terminal business (no opener call)", async () => {
+  test("assistant markdown bare URL and link label open on Ctrl+click", async () => {
     await withTestRenderer(
       async (h) => {
         const shell = createAppShell(h.renderer, {
@@ -352,31 +355,120 @@ describe("Ctrl+clicking a transcript URL", () => {
           opened.push(url);
         });
         try {
-          // Markdown prose paints through childless library renderers with
-          // no text-leaf API to arm or hit-test (docs/TUI.md), so neither
-          // the bare URL nor the explicit link label opens through us.
-          // The real terminal owns those cells; this pins that remainder.
+          // Markdown blocks paint through childless library renderers, so
+          // their clicks are only visible through the bubbling transcript
+          // handler armed by createAppShell.
           appendStreamRow(shell, {
             role: "assistant",
             text: "see https://example.com/docs and [guide](https://example.com/guide) ok",
           });
           // Assistant rows are markdown; their blocks highlight
-          // asynchronously (see shell.test.ts), so the frame only carries
-          // the prose after a settle.
-          await new Promise((resolve) => setTimeout(resolve, 250));
+          // asynchronously (see shell.test.ts), so wait for the paint
+          // instead of sleeping a fixed settle.
+          const bare = await waitForPaintedCell(h, "example.com/docs");
+          await h.mockMouse.click(bare.x, bare.y, 0, {
+            modifiers: { ctrl: true },
+          });
+          await h.renderOnce();
+          expect(opened).toEqual(["https://example.com/docs"]);
+
+          opened.length = 0;
+          const label = await waitForPaintedCell(h, "guide");
+          await h.mockMouse.click(label.x, label.y, 0, {
+            modifiers: { ctrl: true },
+          });
+          await h.renderOnce();
+          expect(opened).toEqual(["https://example.com/guide"]);
+        } finally {
+          resetUrlOpener();
+          shell.dispose();
+        }
+      },
+      { width: 80, height: 24 },
+    );
+  });
+
+  test("plain click on a markdown link does not open", async () => {
+    await withTestRenderer(
+      async (h) => {
+        const shell = createAppShell(h.renderer, {
+          terminal: { columns: 80, rows: 24 },
+          wireKeys: false,
+          run: "idle",
+        });
+        const opened: string[] = [];
+        setUrlOpener((url) => {
+          opened.push(url);
+        });
+        try {
+          appendStreamRow(shell, {
+            role: "assistant",
+            text: "see https://example.com/docs ok",
+          });
+          const bare = await waitForPaintedCell(h, "example.com/docs");
+          await h.mockMouse.click(bare.x, bare.y);
           await h.renderOnce();
+          expect(opened).toEqual([]);
+        } finally {
+          resetUrlOpener();
+          shell.dispose();
+        }
+      },
+      { width: 80, height: 24 },
+    );
+  });
 
-          const bare = findCell(h.captureCharFrame(), "example.com/docs");
-          expect(bare).not.toBeNull();
-          await h.mockMouse.click(defined(bare).x, defined(bare).y, 0, {
+  test("a markdown link to a non-http(s) target never opens", async () => {
+    await withTestRenderer(
+      async (h) => {
+        const shell = createAppShell(h.renderer, {
+          terminal: { columns: 80, rows: 24 },
+          wireKeys: false,
+          run: "idle",
+        });
+        const opened: string[] = [];
+        setUrlOpener((url) => {
+          opened.push(url);
+        });
+        try {
+          appendStreamRow(shell, {
+            role: "assistant",
+            text: "see [target](custom://thing/pull/1) ok",
+          });
+          const label = await waitForPaintedCell(h, "target");
+          await h.mockMouse.click(label.x, label.y, 0, {
             modifiers: { ctrl: true },
           });
           await h.renderOnce();
           expect(opened).toEqual([]);
+        } finally {
+          resetUrlOpener();
+          shell.dispose();
+        }
+      },
+      { width: 80, height: 24 },
+    );
+  });
 
-          const label = findCell(h.captureCharFrame(), "guide");
-          expect(label).not.toBeNull();
-          await h.mockMouse.click(defined(label).x, defined(label).y, 0, {
+  test("Ctrl+press on a markdown link, release off it, does not open", async () => {
+    await withTestRenderer(
+      async (h) => {
+        const shell = createAppShell(h.renderer, {
+          terminal: { columns: 80, rows: 24 },
+          wireKeys: false,
+          run: "idle",
+        });
+        const opened: string[] = [];
+        setUrlOpener((url) => {
+          opened.push(url);
+        });
+        try {
+          appendStreamRow(shell, {
+            role: "assistant",
+            text: "see https://example.com/docs and more prose here ok",
+          });
+          const bare = await waitForPaintedCell(h, "example.com/docs");
+          await h.mockMouse.drag(bare.x, bare.y, bare.x + 30, bare.y, 0, {
             modifiers: { ctrl: true },
           });
           await h.renderOnce();
@@ -389,4 +481,58 @@ describe("Ctrl+clicking a transcript URL", () => {
       { width: 80, height: 24 },
     );
   });
+
+  test("Ctrl+click on an armed plain-row link opens exactly once", async () => {
+    await withTestRenderer(
+      async (h) => {
+        const shell = createAppShell(h.renderer, {
+          terminal: { columns: 80, rows: 24 },
+          wireKeys: false,
+          run: "idle",
+        });
+        const opened: string[] = [];
+        setUrlOpener((url) => {
+          opened.push(url);
+        });
+        try {
+          // The armed row's own release handler opens and stops propagation;
+          // the transcript-root markdown handler must not see the same
+          // gesture and open the (getLinkAt-resolved) target a second time.
+          appendStreamRow(shell, {
+            role: "user",
+            text: "see https://example.com/x ok",
+          });
+          const link = await waitForPaintedCell(h, "example.com");
+          await h.mockMouse.click(link.x, link.y, 0, {
+            modifiers: { ctrl: true },
+          });
+          await h.renderOnce();
+          expect(opened).toEqual(["https://example.com/x"]);
+        } finally {
+          resetUrlOpener();
+          shell.dispose();
+        }
+      },
+      { width: 80, height: 24 },
+    );
+  });
 });
+
+/** Poll until `needle` paints, rendering between tries. */
+async function waitForPaintedCell(
+  h: {
+    renderOnce: () => Promise<void>;
+    captureCharFrame: () => string;
+  },
+  needle: string,
+  timeoutMs = 2000,
+): Promise<{ readonly x: number; readonly y: number }> {
+  const deadline = Date.now() + timeoutMs;
+  for (;;) {
+    await h.renderOnce();
+    const cell = findCell(h.captureCharFrame(), needle);
+    if (cell !== null) return cell;
+    if (Date.now() > deadline) throw new Error(`never painted: ${needle}`);
+    await new Promise((resolve) => setTimeout(resolve, 25));
+  }
+}