Arm wrapped URLs whole and cover agent plain rows

Author: TheGreatAxios

docs/TUI.md

@@ -842,6 +842,8 @@ url.dll,FileProtocolHandler` — argv spawns, never through a shell).
     prefix-match. Hover highlighting needs pointer-motion reports, so the
     main shell enables them (`enableMouseMovement`, DEC ?1003) alongside
     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

src/tui/shell/transcript.ts

@@ -18,6 +18,7 @@ import {
   findLinks,
   paintLinkLine,
   splitLinkSpans,
+  splitWrappedLinkSpans,
 } from "../url-links.js";
 import {
   splitAtSettledHeading,
@@ -33,6 +34,7 @@ import {
   isSentenceRow,
   MAIN_AGENT,
   paintStreamRow,
+  plainRowWrapWidth,
   rowGroupGap,
   streamRowGutter,
   toolRowLines,
@@ -205,7 +207,12 @@ function retextStreamRowBody(
     return false;
   if (node instanceof TextRenderable) {
     if (isMarkdownRow(row)) return false;
-    paintPlainRowNode(node, paintStreamRow(row, layout));
+    paintPlainRowNode(
+      node,
+      row,
+      paintStreamRow(row, layout),
+      plainRowWrapWidth(row, layout),
+    );
     return true;
   }
 
@@ -354,7 +361,12 @@ export function buildRowNode(
   }
 
   if (!isMarkdownRow(row)) {
-    return buildPlainRowNode(ctx, paintStreamRow(row, layout));
+    return buildPlainRowNode(
+      ctx,
+      row,
+      paintStreamRow(row, layout),
+      plainRowWrapWidth(row, layout),
+    );
   }
 
   const gutter = streamRowGutter(row, layout);
@@ -385,24 +397,37 @@ function markdownBodyOptions(gutter: PaintedStreamLine, width: number) {
  */
 function buildPlainRowNode(
   ctx: CliRenderer,
+  row: StreamRow,
   painted: PaintedStreamLine,
+  wrapWidth: number,
 ): TextRenderable {
   const node = new TextRenderable(ctx, {
     content: painted.content,
     fg: painted.fg,
   });
-  paintPlainRowNode(node, painted);
+  paintPlainRowNode(node, row, painted, wrapWidth);
   return node;
 }
 
+/**
+ * Links a plain row's pre-wrap text holds: wrapped fragments reassemble to
+ * one of these, which is what tells a real wrap across a short fragment line
+ * apart from a natural line break after the fact.
+ */
+function plainRowSourceUrls(row: StreamRow): string[] {
+  return findLinks(`${row.text}\n${row.summary ?? ""}`).map((hit) => hit.url);
+}
+
 /**
  * Rewrite a plain row's text on its existing node. The node never changes
  * shape, so a URL appearing or disappearing repaints in place instead of
  * forcing a rebuild.
  */
 function paintPlainRowNode(
   node: TextRenderable,
+  row: StreamRow,
   painted: PaintedStreamLine,
+  wrapWidth: number,
 ): void {
   const lines = painted.content.split("\n");
   if (!lines.some((line) => findLinks(line).length > 0)) {
@@ -415,7 +440,11 @@ function paintPlainRowNode(
   }
   paintLinkLine(
     node,
-    lines.map((line) => splitLinkSpans([{ text: line, fg: painted.fg }])),
+    splitWrappedLinkSpans(
+      lines.map((text) => ({ text: text.trimEnd(), fg: painted.fg })),
+      wrapWidth,
+      plainRowSourceUrls(row),
+    ),
   );
 }
 

src/tui/stream.ts

@@ -387,6 +387,25 @@ function userBubbleLines(text: string, width: number): string[] {
   ];
 }
 
+/**
+ * The painted width a plain row was wrapped at, for reassembling URLs split
+ * across continuation lines. Mirrors the three plain-row layouts: the bubble
+ * wraps its body inside the bar, while thinking and gutter-indented rows fill
+ * the full width. Keep in sync with userBubbleLines/thinkingLines/indentBody.
+ */
+export function plainRowWrapWidth(row: StreamRow, layout: RowLayout): number {
+  if (row.role !== "user") return layout.width;
+  const barWidth = stringWidth(`${BUBBLE_BAR} `);
+  const body = Math.max(
+    1,
+    Math.min(
+      layout.width - barWidth,
+      Math.ceil(layout.width * BUBBLE_MAX_SHARE),
+    ),
+  );
+  return body + barWidth;
+}
+
 /**
  * Columns a reasoning block is inset by. The inset plus the faintest text in
  * the palette is the whole of reasoning's chrome — it carries no marker of its

src/tui/url-click.test.ts

@@ -253,4 +253,140 @@ describe("Ctrl+clicking a transcript URL", () => {
       { width: 80, height: 24 },
     );
   });
+
+  test("a wrapped URL in a thinking row opens the full target", async () => {
+    await withTestRenderer(
+      async (h) => {
+        const shell = createAppShell(h.renderer, {
+          terminal: { columns: 40, rows: 24 },
+          wireKeys: false,
+          run: "idle",
+        });
+        const opened: string[] = [];
+        setUrlOpener((url) => {
+          opened.push(url);
+        });
+        try {
+          // Agent thinking paints through the same plain-row path as user
+          // rows; the long URL wraps mid-run at this width. Before the fix
+          // the row armed the first fragment as its own truncated target.
+          const full =
+            "https://example.com/abcdefghijklmnopqrstuvwxyz0123456789";
+          appendStreamRow(shell, {
+            role: "system",
+            meta: "thinking",
+            text: `checking ${full} today`,
+          });
+          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([full]);
+        } finally {
+          resetUrlOpener();
+          shell.dispose();
+        }
+      },
+      { width: 40, height: 24 },
+    );
+  });
+
+  test("a URL wrapped across bubble lines opens the full target", async () => {
+    await withTestRenderer(
+      async (h) => {
+        const shell = createAppShell(h.renderer, {
+          terminal: { columns: 40, rows: 24 },
+          wireKeys: false,
+          run: "idle",
+        });
+        const opened: string[] = [];
+        setUrlOpener((url) => {
+          opened.push(url);
+        });
+        try {
+          // The bubble body is narrower than the terminal, so the long URL
+          // wraps across continuation rows. Every fragment must resolve to
+          // the one target, not to its own truncated text.
+          const full =
+            "https://example.com/abcdefghijklmnopqrstuvwxyz0123456789";
+          appendStreamRow(shell, {
+            role: "user",
+            text: `see ${full} ok`,
+          });
+          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([full]);
+        } finally {
+          resetUrlOpener();
+          shell.dispose();
+        }
+      },
+      { width: 40, height: 24 },
+    );
+  });
+
+  test("assistant markdown links stay terminal business (no opener call)", 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 {
+          // 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.
+          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));
+          await h.renderOnce();
+
+          const bare = findCell(h.captureCharFrame(), "example.com/docs");
+          expect(bare).not.toBeNull();
+          await h.mockMouse.click(defined(bare).x, defined(bare).y, 0, {
+            modifiers: { ctrl: true },
+          });
+          await h.renderOnce();
+          expect(opened).toEqual([]);
+
+          const label = findCell(h.captureCharFrame(), "guide");
+          expect(label).not.toBeNull();
+          await h.mockMouse.click(defined(label).x, defined(label).y, 0, {
+            modifiers: { ctrl: true },
+          });
+          await h.renderOnce();
+          expect(opened).toEqual([]);
+        } finally {
+          resetUrlOpener();
+          shell.dispose();
+        }
+      },
+      { width: 80, height: 24 },
+    );
+  });
 });