Merge pull request #1055 from corbitsdev/corbitsdev/cl-7967-link-module-split

Split transcript link helpers into focused modules

Author: TheGreatAxios

src/tui/link-open.ts

@@ -0,0 +1,87 @@
+/**
+ * Opening: the openable-URL gate plus the browser opener behind it.
+ *
+ * openUrl is the single opener choke point: every armed-row and markdown
+ * release path opens through it, and its isOpenableUrl check is the gate
+ * that decides. The isOpenableUrl pre-filters in linkColumnHits and
+ * followWrapChain stay as defense-in-depth — they keep non-http(s) targets
+ * out of highlight and wrap-fusion geometry — and are deliberately not
+ * consolidated into this one call site.
+ */
+import type { MouseEvent } from "@opentui/core";
+
+/**
+ * Only http(s) targets ever open. Markdown authors can point a link at any
+ * scheme (`javascript:`, `file:`, `mailto:`), so the gate parses rather than
+ * prefix-matching.
+ */
+export function isOpenableUrl(url: string): boolean {
+  try {
+    const protocol = new URL(url).protocol;
+    return protocol === "http:" || protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+
+export type UrlOpener = (url: string) => void;
+
+/**
+ * Argv for opening a URL with the platform handler, without a shell. Windows
+ * must never route through `cmd /c start`: cmd.exe re-parses the assembled
+ * command line, so `&`, `|` and `&&` in an attacker-influenceable transcript
+ * URL would execute as command separators. `rundll32 url.dll,FileProtocolHandler`
+ * takes the URL as a plain argv element instead.
+ */
+export function platformUrlCommand(platform: string, url: string): string[] {
+  if (platform === "darwin") return ["open", url];
+  if (platform === "win32")
+    return ["rundll32", "url.dll,FileProtocolHandler", url];
+  return ["xdg-open", url];
+}
+
+/**
+ * The open gesture: left press while Ctrl is held. Cmd on macOS is the
+ * terminal's own OSC-8 click (it handles Cmd+click itself and the app never
+ * sees the press); Ctrl is what SGR mouse reports carry on every platform.
+ */
+export function isUrlOpenClick(
+  event: Pick<MouseEvent, "button" | "modifiers">,
+): boolean {
+  return event.button === 0 && event.modifiers.ctrl === true;
+}
+
+function defaultUrlOpener(url: string): void {
+  const command = platformUrlCommand(process.platform, url);
+  try {
+    Bun.spawn(command, {
+      stdout: "ignore",
+      stderr: "ignore",
+      stdin: "ignore",
+    }).unref();
+  } catch {
+    // Fire-and-forget from a hover/click handler with no status line to
+    // report to; a missing opener must not break the transcript.
+  }
+}
+
+let currentOpener: UrlOpener = defaultUrlOpener;
+
+/** Test seam: swap the browser opener, `resetUrlOpener` restores it. */
+export function setUrlOpener(opener: UrlOpener): void {
+  currentOpener = opener;
+}
+
+export function resetUrlOpener(): void {
+  currentOpener = defaultUrlOpener;
+}
+
+/** Open an http(s) URL in the default browser; anything else is ignored. */
+export function openUrl(url: string): void {
+  if (!isOpenableUrl(url)) return;
+  try {
+    currentOpener(url);
+  } catch {
+    // Same fire-and-forget contract as the default opener above.
+  }
+}

src/tui/link-spans.ts

@@ -0,0 +1,126 @@
+/** URL spans: bare http(s) scanning plus splitting styled runs on hits. */
+export interface LinkSpan {
+  readonly text: string;
+  readonly fg: string;
+  readonly bold?: boolean | undefined;
+  readonly url: string | null;
+}
+
+export interface LinkHit {
+  readonly url: string;
+  readonly start: number;
+  readonly end: number;
+}
+
+const URL_PATTERN = /https?:\/\/[^\s<>"'`\]]+/gi;
+const TRAILING_PUNCTUATION = new Set([
+  ".",
+  ",",
+  ";",
+  ":",
+  "!",
+  "?",
+  "'",
+  '"',
+  "]",
+  "}",
+  ">",
+]);
+
+/** http(s) runs inside plain text, without trailing prose punctuation. */
+export function findLinks(text: string): LinkHit[] {
+  const hits: LinkHit[] = [];
+  URL_PATTERN.lastIndex = 0;
+  for (const match of text.matchAll(URL_PATTERN)) {
+    const end = trimUrlEnd(text, match.index, match.index + match[0].length);
+    if (end > match.index)
+      hits.push({ url: text.slice(match.index, end), start: match.index, end });
+  }
+  return hits;
+}
+
+/**
+ * The end of a URL match once prose punctuation is out: trailing sentence
+ * punctuation never belongs to the link, and a closing paren only does when
+ * the match opened one to balance it.
+ */
+export function trimUrlEnd(text: string, start: number, end: number): number {
+  let trimmed = end;
+  while (trimmed > start) {
+    const tail = text[trimmed - 1];
+    if (tail === undefined || !TRAILING_PUNCTUATION.has(tail)) break;
+    trimmed -= 1;
+  }
+  let depth = 0;
+  for (let i = start; i < trimmed; i += 1) {
+    if (text[i] === "(") depth += 1;
+    if (text[i] === ")") depth -= 1;
+  }
+  while (trimmed > start && text[trimmed - 1] === ")" && depth < 0) {
+    trimmed -= 1;
+    depth += 1;
+  }
+  return trimmed;
+}
+
+/** Split styled segments so URL runs become their own spans. */
+export function splitLinkSpans(
+  segments: readonly { text: string; fg: string; bold?: boolean | undefined }[],
+): LinkSpan[] {
+  const spans: LinkSpan[] = [];
+  for (const segment of segments) {
+    spans.push(
+      ...sliceSpans(
+        segment,
+        findLinks(segment.text).map((hit): SliceHit => ({
+          ...hit,
+          text: hit.url,
+        })),
+      ),
+    );
+  }
+  return spans;
+}
+
+/** A hit with the exact text its span paints (trimmed of prose punctuation). */
+export interface SliceHit extends LinkHit {
+  readonly text: string;
+}
+
+/** Cut one segment on explicit hits; a hitless segment stays one null span. */
+export function sliceSpans(
+  segment: { text: string; fg: string; bold?: boolean | undefined },
+  hits: readonly SliceHit[],
+): LinkSpan[] {
+  if (hits.length === 0) {
+    return [
+      { text: segment.text, fg: segment.fg, bold: segment.bold, url: null },
+    ];
+  }
+  const spans: LinkSpan[] = [];
+  let cursor = 0;
+  for (const hit of hits) {
+    if (hit.start > cursor)
+      spans.push({
+        text: segment.text.slice(cursor, hit.start),
+        fg: segment.fg,
+        bold: segment.bold,
+        url: null,
+      });
+    spans.push({
+      text: hit.text,
+      fg: segment.fg,
+      bold: segment.bold,
+      url: hit.url,
+    });
+    cursor = hit.end;
+  }
+  if (cursor < segment.text.length)
+    spans.push({
+      text: segment.text.slice(cursor),
+      fg: segment.fg,
+      bold: segment.bold,
+      url: null,
+    });
+  return spans;
+}