railmux 0.4.2.dev6__tar.gz → 0.4.2.dev8__tar.gz

{railmux-0.4.2.dev6/src/railmux.egg-info → railmux-0.4.2.dev8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.2.dev6
+Version: 0.4.2.dev8
 Summary: Terminal UI to navigate, resume, and start Claude Code and Codex sessions
 Author-email: Rightglow <zhang.taian@foxmail.com>
 License-Expression: MIT

railmux-0.4.2.dev8/src/railmux/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.4.2.dev8"

{railmux-0.4.2.dev6 → railmux-0.4.2.dev8}/src/railmux/fast_display_server.py

@@ -89,6 +89,7 @@ from railmux.terminal_screen import (
     HyperlinkTrackingStream,
     Osc52ClipboardDecoder as _Osc52ClipboardDecoder,
     ScreenState as _ScreenState,
+    _safe_hyperlink,
     build_screen_update,
     extended_pyte as _extended_pyte,
     render_rows,
@@ -1616,11 +1617,17 @@ def _read_transcript_tail(fd: int) -> tuple[str, bool]:
 def _wrap_transcript_rows(
     pyte: object, text: str, width: int
 ) -> tuple[tuple[bytes, ...], bool, int]:
-    """Wrap allowlisted transcript ANSI into independently paintable rows."""
+    """Wrap allowlisted transcript ANSI into independently paintable rows.
+
+    SGR styles and HTTP(S) OSC 8 links are kept; a link that crosses a row
+    break is closed at the row end and reopened on the next row, as
+    :func:`render_rows` emits links for captured screen rows.
+    """
     rows: deque[bytes] = deque(maxlen=MAX_HISTORY_LINES)
     row = bytearray(b"\033[0m")
     column = 0
     active: list[bytes] = []
+    link = b""
     dropped = False
     total_rows = 0
 
@@ -1629,12 +1636,28 @@ def _wrap_transcript_rows(
         total_rows += 1
         if len(rows) == rows.maxlen:
             dropped = True
-        rows.append(bytes(row) + b"\033[0m")
-        row = bytearray(b"\033[0m" + b"".join(active))
+        rows.append(bytes(row) + (_LINK_END if link else b"") + b"\033[0m")
+        row = bytearray(b"\033[0m" + b"".join(active) + link)
         column = 0
 
-    for match in re.finditer(r"\x1b\[[0-9;]*m|[^\x1b]+", text):
+    for match in re.finditer(
+        r"\x1b\[[0-9;]*m|\x1b\]8;;([^\x1b]*)\x1b\\|[^\x1b]+", text
+    ):
         token = match.group(0)
+        if token.startswith("\x1b]"):
+            target = match.group(1)
+            if target and _safe_hyperlink(target.encode("utf-8")) is None:
+                continue
+            encoded = token.encode("utf-8")
+            if link and target:
+                row.extend(_LINK_END)
+            if target:
+                link = encoded
+                row.extend(encoded)
+            elif link:
+                link = b""
+                row.extend(_LINK_END)
+            continue
         if token.startswith("\x1b["):
             encoded = token.encode("ascii")
             params = token[2:-1].split(";")
@@ -1672,7 +1695,7 @@ def _wrap_transcript_rows(
                 finish()
             row.extend(char.encode("utf-8"))
             column += max(0, cell_width)
-    if column or len(row) > len(b"\033[0m" + b"".join(active)):
+    if column or len(row) > len(b"\033[0m" + b"".join(active) + link):
         finish()
     return tuple(rows), dropped, total_rows
 
@@ -1750,7 +1773,9 @@ def _transcript_rows(
         os.close(fd)
 
 
-_OVERLAP_STYLE_RE = re.compile(rb"\x1b\[[0-9;]*m")
+_LINK_END = b"\033]8;;\033\\"
+_OVERLAP_STYLE_RE = re.compile(
+    rb"\x1b\[[0-9;]*m|\x1b\]8;;[^\x1b]*\x1b\\")
 _OVERLAP_SPACE_RE = re.compile(r"\s+")
 _OVERLAP_ANCHOR_CHARS = 12
 _OVERLAP_SINGLE_ANCHOR_CHARS = 24

{railmux-0.4.2.dev6 → railmux-0.4.2.dev8}/src/railmux/transcript.py

@@ -13,6 +13,7 @@ import os
 import re
 import sys
 from pathlib import Path
+from urllib.parse import urlsplit
 
 # ── ANSI styles ──────────────────────────────────────────────────────────
 BOLD = "\033[1m"
@@ -28,6 +29,7 @@ ITALIC = "\033[3m"
 BOLD_OFF = "\033[22m"
 ITALIC_OFF = "\033[23m"
 FG_DEFAULT = "\033[39m"
+LINK_END = "\033]8;;\033\\"
 
 _CODEX_SYNTHETIC_PREFIXES = (
     "<environment_context>",
@@ -235,13 +237,16 @@ _MD_INLINE_RE = re.compile(
     r"|\*\*(?=\S)(.+?)(?<=\S)\*\*"
     r"|__(?=\S)(.+?)(?<=\S)__"
     r"|(?<![\w*])\*(?=[^\s*])(.+?)(?<=[^\s*])\*(?![\w*])"
+    r"|\[([^\]\n]+)\]\(([^)\s]+)\)"
 )
 _MD_TABLE_SEPARATOR_RE = re.compile(
     r"^\s*\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)*\|?\s*$")
 _MD_TABLE_CELL_SPLIT_RE = re.compile(r"(?<!\\)\|")
 _LIST_HANG_RE = re.compile(r" *(?:(?:[-*+]|\d+[.)]) +)?")
-_SGR_RE = re.compile(r"\x1b\[[0-9;]*m")
-_WRAP_TOKEN_RE = re.compile(r"\x1b\[[0-9;]*m| +|[^ \x1b]+")
+# Zero-width escapes Railmux emits itself: SGR styles and OSC 8 links.
+_ESCAPE_RE = re.compile(r"\x1b\[[0-9;]*m|\x1b\]8;;[^\x1b]*\x1b\\")
+_WRAP_TOKEN_RE = re.compile(
+    r"\x1b\[[0-9;]*m|\x1b\]8;;[^\x1b]*\x1b\\| +|[^ \x1b]+")
 _TASK_SUMMARY_RE = re.compile(r"<summary>(.*?)</summary>", re.DOTALL)
 
 _char_width_function = None
@@ -267,7 +272,7 @@ def _visible_width(text: str) -> int:
     # Claude pads an emoji-presentation selector (as in "⚠️") to two cells.
     return sum(
         1 if char == "\ufe0f" else _char_width(char)
-        for char in _SGR_RE.sub("", text)
+        for char in _ESCAPE_RE.sub("", text)
     )
 
 
@@ -305,12 +310,16 @@ def _wrap_styled(line: str, width: int, hang: int) -> list[str]:
             else:
                 newline()
             continue
-        if (
-            column + token_width > width
-            and column > hang
-            and token_width <= width - hang
-        ):
-            newline()
+        capacity = width - hang
+        if column + token_width > width and column > hang:
+            # Like wrap-ansi: start a word on a fresh row when that fits it,
+            # or when splitting it from there needs fewer breaks.
+            breaks_here = 1 + (token_width - (width - column) - 1) // capacity
+            if (
+                token_width <= capacity
+                or (token_width - 1) // capacity < breaks_here
+            ):
+                newline()
         for char in token:
             char_width = _char_width(char)
             if column + char_width > width and column > hang:
@@ -323,29 +332,49 @@ def _wrap_styled(line: str, width: int, hang: int) -> list[str]:
 
 def _hang_for(row: str, prefix: int) -> int:
     """Hanging indent for a row whose own content starts after *prefix* cells."""
-    content = _SGR_RE.sub("", row)[prefix:]
+    content = _ESCAPE_RE.sub("", row)[prefix:]
     return prefix + len(_LIST_HANG_RE.match(content).group(0))
 
 
 def _close_fragments(fragments: list[str]) -> list[str]:
-    """Make each wrapped fragment carry and close its own SGR state.
+    """Make each wrapped fragment carry and close its own SGR and link state.
 
-    Table cells sit beside other cells on one row, so a style that continues
-    onto a cell's next fragment must not leak across the borders between.
+    Table cells sit beside other cells on one row, so a style or link that
+    continues onto a cell's next fragment must not leak across the borders.
     """
     closed: list[str] = []
     active: list[str] = []
+    link = ""
     for fragment in fragments:
-        prefix = "".join(active)
-        for code in _SGR_RE.findall(fragment):
-            if code == RESET:
+        prefix = "".join(active) + link
+        for code in _ESCAPE_RE.findall(fragment):
+            if code.startswith("\x1b]"):
+                link = "" if code == LINK_END else code
+            elif code == RESET:
                 active.clear()
             else:
                 active.append(code)
-        closed.append(f"{prefix}{fragment}{RESET}")
+        suffix = LINK_END if link else ""
+        closed.append(f"{prefix}{fragment}{suffix}{RESET}")
     return closed
 
 
+def _link(text: str, url: str) -> str:
+    """Wrap *text* in an OSC 8 link when *url* is a plain HTTP(S) target."""
+    try:
+        parsed = urlsplit(url)
+        valid = (
+            parsed.scheme.lower() in ("http", "https")
+            and parsed.hostname is not None
+            and len(url) <= 8192
+        )
+    except ValueError:
+        valid = False
+    if not valid:
+        return text
+    return f"\033]8;;{url}\033\\{text}{LINK_END}"
+
+
 def _table_cells(line: str) -> list[str]:
     stripped = line.strip()
     if stripped.startswith("|"):
@@ -373,15 +402,34 @@ def _markdown_table(lines: list[str], width: int) -> list[str] | None:
     for line in lines[2:]:
         cells = [_markdown_inline(cell) for cell in _table_cells(line)]
         body.append((cells + [""] * count)[:count])
-    available = width - 1 - 3 * count
+    # Claude keeps two spare cells beside the borders and padding.
+    available = width - 3 - 3 * count
     if available < 3 * count:
         return None
+    rows = [header, *body]
     natural = [
-        max(1, *(_visible_width(row[index]) for row in [header, *body]))
+        max(1, *(_visible_width(row[index]) for row in rows))
+        for index in range(count)
+    ]
+    longest_word = [
+        max(
+            _visible_width(word)
+            for row in rows
+            for word in [*_ESCAPE_RE.sub("", row[index]).split(" "), ""]
+        )
         for index in range(count)
     ]
+    minimum = [max(1, min(a, b)) for a, b in zip(natural, longest_word)]
     widths = natural
-    if sum(natural) > available:
+    if sum(natural) > available and sum(minimum) <= available:
+        # Claude's split: every column fits its longest word, and the spare
+        # cells go to each column in proportion to how much more it wants.
+        spare = available - sum(minimum)
+        wanted = sum(n - m for n, m in zip(natural, minimum))
+        widths = [
+            m + spare * (n - m) // wanted for n, m in zip(natural, minimum)
+        ]
+    elif sum(natural) > available:
         low, high = 3, max(natural)
         while low < high:
             cap = (low + high + 1) // 2
@@ -419,11 +467,12 @@ def _markdown_table(lines: list[str], width: int) -> list[str] | None:
 
 
 def _markdown_inline(line: str, *, bold: bool = False) -> str:
-    """Style inline code, bold and italic spans like Claude's markdown view.
+    """Style inline code, bold, italic and link spans like Claude's view.
 
     Only targeted "off" codes close each span, so an enclosing style (for
     example a bold heading) survives an inner code or italic span. *bold*
     marks an already-bold context whose nested strong spans must not end it.
+    A link shows only its text and stays clickable through OSC 8.
     """
 
     def replace(match: re.Match[str]) -> str:
@@ -431,6 +480,9 @@ def _markdown_inline(line: str, *, bold: bool = False) -> str:
             match.group(2), match.group(3), match.group(4), match.group(5))
         if code is not None:
             return f"{CLAUDE_ACCENT}{code}{FG_DEFAULT}"
+        if match.group(6) is not None:
+            return _link(_markdown_inline(match.group(6), bold=bold),
+                         match.group(7))
         if strong is not None or strong_alt is not None:
             inner = _markdown_inline(
                 strong if strong is not None else strong_alt, bold=True)
@@ -477,6 +529,9 @@ def _markdown_lines(lines: list[str], width: int | None = None) -> list[str]:
         if heading:
             inner = _markdown_inline(heading.group(2), bold=True)
             rendered.append(f"{BOLD}{inner}{RESET}")
+            # Claude always leaves a blank line below a heading.
+            if index < len(lines) and lines[index].strip():
+                rendered.append("")
             continue
         styled = _markdown_inline(line)
         rendered.append(styled + RESET if styled != line else line)

{railmux-0.4.2.dev6 → railmux-0.4.2.dev8/src/railmux.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.2.dev6
+Version: 0.4.2.dev8
 Summary: Terminal UI to navigate, resume, and start Claude Code and Codex sessions
 Author-email: Rightglow <zhang.taian@foxmail.com>
 License-Expression: MIT

{railmux-0.4.2.dev6 → railmux-0.4.2.dev8}/tests/test_fast_display_server.py

@@ -2357,3 +2357,19 @@ def test_server_projects_only_allowlisted_private_terminal_modes():
         mode = {1000 << 5, 1006 << 5, 9999 << 5}
 
     assert terminal_modes_for_screen(OtherModes()) is TerminalMode.NONE
+
+
+def test_transcript_rows_reopen_links_across_wraps_and_drop_unsafe_targets():
+    pyte = fast_display_server._extended_pyte(__import__("pyte"))
+    link = "\x1b]8;;https://example.com/a\x1b\\"
+    close = "\x1b]8;;\x1b\\"
+    text = f"{link}abcdef{close} \x1b]8;;file:///etc/passwd\x1b\\x{close}\n"
+
+    rows, _dropped, _total = fast_display_server._wrap_transcript_rows(
+        pyte, text, 4)
+
+    encoded_link, encoded_close = link.encode(), close.encode()
+    assert rows[0] == b"\x1b[0m" + encoded_link + b"abcd" + encoded_close + b"\x1b[0m"
+    assert rows[1].startswith(b"\x1b[0m" + encoded_link + b"ef" + encoded_close)
+    assert b"file:" not in b"".join(rows)
+    assert fast_display_server._overlap_text(rows[0]) == "abcd"

{railmux-0.4.2.dev6 → railmux-0.4.2.dev8}/tests/test_transcript.py

@@ -905,7 +905,9 @@ def _native(records, width=None):
 
 
 def _plain_rows(rendered: str) -> list[str]:
-    return re.sub(r"\x1b\[[0-9;]*m", "", rendered).split("\n")
+    return re.sub(
+        r"\x1b\[[0-9;]*m|\x1b\]8;;[^\x1b]*\x1b\\", "", rendered
+    ).split("\n")
 
 
 def _assistant(text: str) -> dict:
@@ -962,12 +964,55 @@ def test_claude_native_history_draws_tables_that_fit_the_pane():
     rows = _plain_rows(_native([_assistant(table)], width=30))[1:-1]
 
     assert rows == [
-        "● ┌──────┬───────────────────┐",
-        "  │ Name │ Notes             │",
-        "  ├──────┼───────────────────┤",
-        "  │ a    │ one two three     │",
-        "  │      │ four              │",
-        "  └──────┴───────────────────┘",
+        "● ┌──────┬─────────────────┐",
+        "  │ Name │ Notes           │",
+        "  ├──────┼─────────────────┤",
+        "  │ a    │ one two three   │",
+        "  │      │ four            │",
+        "  └──────┴─────────────────┘",
     ]
     assert all(len(row) <= 30 for row in rows)
     assert table.splitlines()[0] in _native([_assistant(table)])
+
+
+def test_claude_native_history_matches_claude_table_and_link_layout():
+    table = "\n".join([
+        "### Title",
+        "| PR | Notes |",
+        "|---|---|",
+        "| [#1](https://example.com/pull/1) | "
+        + "alpha beta gamma delta epsilon zeta eta theta |",
+    ])
+    rows = _plain_rows(_native([_assistant(table)], width=40))[1:-1]
+
+    assert rows == [
+        "● Title",
+        "  ",
+        "  ┌────┬─────────────────────────────┐",
+        "  │ PR │ Notes                       │",
+        "  ├────┼─────────────────────────────┤",
+        "  │ #1 │ alpha beta gamma delta      │",
+        "  │    │ epsilon zeta eta theta      │",
+        "  └────┴─────────────────────────────┘",
+    ]
+
+
+def test_claude_native_wrap_moves_long_word_when_that_saves_a_break():
+    moved = _native([_assistant("intro " + "x" * 36)], width=20)
+    kept = _native([_assistant("intro " + "x" * 30)], width=20)
+
+    assert _plain_rows(moved)[1:-1] == [
+        "● intro", "  " + "x" * 18, "  " + "x" * 18,
+    ]
+    assert _plain_rows(kept)[1:-1] == [
+        "● intro " + "x" * 12, "  " + "x" * 18,
+    ]
+
+
+def test_claude_native_links_stay_clickable_and_reject_other_schemes():
+    rendered = _native([_assistant(
+        "See [#1](https://example.com/pull/1) and [x](javascript:alert).")])
+
+    assert "\x1b]8;;https://example.com/pull/1\x1b\\#1\x1b]8;;\x1b\\" in rendered
+    assert "javascript" not in rendered
+    assert "See #1 and x." in "\n".join(_plain_rows(rendered))

railmux-0.4.2.dev6/src/railmux/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.4.2.dev6"