railmux 0.4.0.dev32__tar.gz → 0.4.0.dev33__tar.gz

{railmux-0.4.0.dev32/src/railmux.egg-info → railmux-0.4.0.dev33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.0.dev32
+Version: 0.4.0.dev33
 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.0.dev33/src/railmux/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.4.0.dev33"

{railmux-0.4.0.dev32 → railmux-0.4.0.dev33}/src/railmux/transcript.py

@@ -7,6 +7,7 @@ Usage::
 
 from __future__ import annotations
 
+import io
 import json
 import os
 import sys
@@ -41,17 +42,46 @@ _SKIP_TYPES = frozenset({
 })
 
 # Top-level record types that only ever appear in a Codex rollout JSONL.  The
-# preview pipeline in the UI runs ``tail -n 2000`` before piping into this
-# module, so for rollouts longer than 2000 lines the leading ``session_meta``
-# header is dropped and the first record seen here is a ``response_item`` /
-# ``event_msg`` / ``turn_context``.  Detect Codex by the *presence* of any of
-# these types rather than by a leading ``session_meta`` (see issue #5).
+# preview reader keeps only the final 2,000 records, so for longer rollouts the
+# leading ``session_meta`` header is dropped and the first record seen here is
+# a ``response_item`` / ``event_msg`` / ``turn_context``.  Detect Codex by the
+# *presence* of any of these types rather than by a leading ``session_meta``
+# (see issue #5).
 _CODEX_TYPES = frozenset({
     "session_meta", "response_item", "event_msg", "turn_context",
     "compacted", "world_state",
 })
 _CLAUDE_TYPES = _SKIP_TYPES | frozenset({"user", "assistant"})
 
+_TAIL_BLOCK_SIZE = 64 * 1024
+
+
+def _tail_utf8_lines(path: Path, limit: int) -> io.StringIO:
+    """Return the final *limit* UTF-8 lines without scanning from the start.
+
+    The preview caller previously launched a separate ``tail`` process before
+    the Python renderer.  Reading backwards here removes that process from the
+    latency-sensitive Windows path while retaining the same record boundary.
+    One extra newline is collected before slicing so the first returned line
+    can never be a block-boundary fragment.
+    """
+    chunks: list[bytes] = []
+    newline_count = 0
+    with path.open("rb") as stream:
+        stream.seek(0, os.SEEK_END)
+        position = stream.tell()
+        while position > 0 and newline_count <= limit:
+            size = min(_TAIL_BLOCK_SIZE, position)
+            position -= size
+            stream.seek(position)
+            chunk = stream.read(size)
+            chunks.append(chunk)
+            newline_count += chunk.count(b"\n")
+    payload = b"".join(reversed(chunks))
+    lines = payload.splitlines(keepends=True)
+    selected = b"".join(lines[-limit:])
+    return io.StringIO(selected.decode("utf-8", errors="replace"))
+
 
 def _sanitize_text(value: object) -> str:
     """Return display text with terminal control sequences made inert.
@@ -382,8 +412,8 @@ def format_transcript(
 
     *fmt* is an optional explicit format hint (``"codex"`` or ``"claude"``).
     When omitted (the default), the format is auto-detected from the record
-    types actually present in the stream, so a Codex rollout whose leading
-    ``session_meta`` header was stripped by ``tail`` still renders as Codex.
+    types actually present in the stream, so a bounded Codex rollout whose
+    leading ``session_meta`` header was omitted still renders as Codex.
 
     Callers should write each chunk to stdout, e.g.::
 
@@ -670,7 +700,15 @@ def main(argv: list[str] | None = None) -> None:
         if not jsonl_path.exists():
             print(f"File not found: {jsonl_path}", file=sys.stderr)
             sys.exit(1)
-        stream = jsonl_path
+        try:
+            stream = (
+                _tail_utf8_lines(jsonl_path, preview_limit)
+                if preview_limit is not None
+                else jsonl_path
+            )
+        except OSError:
+            print(f"Could not read: {jsonl_path}", file=sys.stderr)
+            sys.exit(1)
 
     try:
         if preview_limit is not None:

{railmux-0.4.0.dev32 → railmux-0.4.0.dev33}/src/railmux/ui/app.py

@@ -100,6 +100,7 @@ from railmux.ui.workspace import (
     COMPACT_RESIZE_OPTION,
     DUAL_SIDEBAR_MIN_WIDTH,
     DUAL_SIDEBAR_PERCENT,
+    DisplayTransportKind,
     MINIMUM_AGENT_PANE_SIZE,
     SINGLE_SIDEBAR_PERCENT,
     SlotRestoreState,
@@ -1177,6 +1178,7 @@ class App:
         *,
         mode_key: str | None = None,
         project_key: str | None = None,
+        sync_transcript_source: bool = True,
     ) -> None:
         """Update one slot, painting sidebar highlights only for the Target."""
         slot.active_session_id = session_id
@@ -1202,7 +1204,8 @@ class App:
             )
         elif session_id is None:
             slot.project_key = None
-        self._sync_slot_transcript_source(slot, session_id, tmux_name)
+        if sync_transcript_source:
+            self._sync_slot_transcript_source(slot, session_id, tmux_name)
         self._paint_slot_active_target(slot, session_id, tmux_name)
 
     def _sync_slot_transcript_source(
@@ -1296,7 +1299,8 @@ class App:
     def _set_active_target(self, session_id: str | None,
                            tmux_name: str | None, *,
                            mode_key: str | None = None,
-                           project_key: str | None = None) -> None:
+                           project_key: str | None = None,
+                           sync_transcript_source: bool = True) -> None:
         """Compatibility entry point for the currently exposed primary slot."""
         self._set_slot_active_target(
             self._primary_slot,
@@ -1304,6 +1308,7 @@ class App:
             tmux_name,
             mode_key=mode_key,
             project_key=project_key,
+            sync_transcript_source=sync_transcript_source,
         )
 
     def _set_active_tmux_target(
@@ -2104,10 +2109,19 @@ class App:
             }
             if slot is self._primary_slot:
                 self._set_active_target(
-                    session.session_id, None, **target_kwargs)
+                    session.session_id,
+                    None,
+                    sync_transcript_source=False,
+                    **target_kwargs,
+                )
             else:
                 self._set_slot_active_target(
-                    slot, session.session_id, None, **target_kwargs)
+                    slot,
+                    session.session_id,
+                    None,
+                    sync_transcript_source=False,
+                    **target_kwargs,
+                )
             if not self._show_attention_status(session.attention):
                 self._set_status(
                     f"≡ Previewing {session.display_title} (current history)")
@@ -2197,11 +2211,11 @@ class App:
         import sys as _sys
         mouse = self._less_mouse_flag
         slot = slot or self._agent_workspace().target
-        # Tail the last 2000 lines so large sessions appear instantly. Tailing
-        # drops the leading ``session_meta`` record, so a long Codex rollout
-        # would otherwise be auto-detected as Claude and render blank. Pass the
-        # format explicitly from SessionMeta.session_type so the parser doesn't
-        # have to guess from the first tailed record (#5).
+        # The renderer reads the last 2000 records itself so large sessions
+        # appear instantly without launching a separate ``tail`` process.
+        # This drops the leading ``session_meta`` record from long Codex
+        # rollouts, so pass the format explicitly from SessionMeta rather than
+        # asking the bounded input to auto-detect it (#5).
         fmt = "codex" if session_type == "codex" else "claude"
         path = shlex.quote(str(jsonl_path))
         python = shlex.quote(_sys.executable)
@@ -2210,9 +2224,8 @@ class App:
         # and suppress any user-configured input pre/postprocessors.
         less_env = ("LESSSECURE=1 LESSHISTFILE=- "
                     "LESSOPEN= LESSCLOSE=")
-        cmd = (f"tail -n 2000 {path} | "
-               f"{python} -m railmux.transcript --format {fmt} "
-               f"--preview-limit 2000 - | "
+        cmd = (f"{python} -m railmux.transcript --format {fmt} "
+               f"--preview-limit 2000 {path} | "
                f"{less_env} less -R +G {mouse}").rstrip()
         restore = slot.restore_state
         controller = getattr(self, "_railmux_pane_id", None)
@@ -2225,33 +2238,58 @@ class App:
                 f"{shlex.quote(controller)} -- "
                 f"{shlex.quote(restore_sequence)}"
             )
-        # In swap mode ``slot.pane_id`` is the real provider pane. Return it
-        # home before the destructive ``respawn-pane -k`` below; only the
-        # display placeholder may be replaced by the transcript viewer.
-        if not self._display_transport().prepare_preview(slot):
-            self._set_status(
-                "failed to return the agent home before transcript preview",
-                "error",
-            )
-            return False
-        self._sync_slot_transcript_source(slot, None, None)
-        if slot.pane_id and tmux_ctl.pane_alive(slot.pane_id):
+        # A preview-to-preview switch keeps the same Railmux-owned outer pane,
+        # whose provider and SSH transcript markers were already cleared by
+        # the first transition.  ``respawn-pane`` is itself the bounded
+        # liveness check, so do not launch redundant tmux clients on this hot
+        # path.  Entering preview from a live agent still uses the complete
+        # return-home identity transaction below.
+        replacing_preview = bool(
+            slot.in_history_mode
+            and slot.pane_id
+            and slot.agent_tmux_name is None
+            and slot.swap_state is None
+            and slot.transport_kind is DisplayTransportKind.NESTED
+        )
+        if replacing_preview:
+            assert slot.pane_id is not None
             if not tmux_ctl.respawn_pane(slot.pane_id, cmd):
                 self._set_status("failed to respawn right pane for transcript")
                 return False
         else:
-            new_id = tmux_ctl.split_window_h(cmd, size_percent=70, detached=True)
-            if not new_id:
-                self._set_status("failed to create right pane for transcript")
+            # In swap mode ``slot.pane_id`` is the real provider pane. Return
+            # it home before the destructive ``respawn-pane -k`` below; only
+            # the display placeholder may be replaced by the viewer.
+            if not self._display_transport().prepare_preview(slot):
+                self._set_status(
+                    "failed to return the agent home before transcript preview",
+                    "error",
+                )
                 return False
-            slot.pane_id = new_id
-            self._set_railmux_focus(self._railmux_has_focus, force_border=True)
+            self._sync_slot_transcript_source(slot, None, None)
+            # prepare_preview already proved an existing pane immediately
+            # before this mutation.  A race now fails in respawn-pane rather
+            # than paying for a second process-wide list-panes query.
+            if slot.pane_id:
+                if not tmux_ctl.respawn_pane(slot.pane_id, cmd):
+                    self._set_status("failed to respawn right pane for transcript")
+                    return False
+            else:
+                new_id = tmux_ctl.split_window_h(
+                    cmd, size_percent=70, detached=True)
+                if not new_id:
+                    self._set_status("failed to create right pane for transcript")
+                    return False
+                slot.pane_id = new_id
+                self._set_railmux_focus(
+                    self._railmux_has_focus, force_border=True)
         # The display pane is now showing a transcript, not an agent session.
         slot.agent_tmux_name = None
         slot.mode_key = self._current_mode_key()
-        self._set_divider_active(
-            not getattr(self, "_railmux_has_focus", True), force=True)
-        self._install_tmux_bindings()
+        if not replacing_preview:
+            self._set_divider_active(
+                not getattr(self, "_railmux_has_focus", True), force=True)
+            self._install_tmux_bindings()
         return True
 
     def _sync_sidebar_to_agent_project(self, tmux_name: str | None) -> None:

{railmux-0.4.0.dev32 → railmux-0.4.0.dev33/src/railmux.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.0.dev32
+Version: 0.4.0.dev33
 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.0.dev32 → railmux-0.4.0.dev33}/tests/test_codex_delete.py

@@ -655,7 +655,10 @@ def test_show_transcript_codex_passes_explicit_format(monkeypatch):
     app, captured = _transcript_app(monkeypatch)
     assert app._show_transcript(Path("/tmp/r.jsonl"), session_type="codex")
     assert captured["prepared"] is True
-    assert "railmux.transcript --format codex --preview-limit 2000 -" in captured["cmd"]
+    assert (
+        "railmux.transcript --format codex --preview-limit 2000 /tmp/r.jsonl"
+        in captured["cmd"]
+    )
 
 
 def test_show_transcript_claude_passes_explicit_format(monkeypatch):
@@ -670,8 +673,8 @@ def test_show_transcript_uses_secure_read_only_pager_and_quotes_python(monkeypat
     assert app._show_transcript(Path("/tmp/a file.jsonl"), session_type="codex")
     cmd = captured["cmd"]
     assert "'/tmp/Python Dir/python' -m railmux.transcript" in cmd
-    assert "tail -n 2000 '/tmp/a file.jsonl'" in cmd
-    assert "--preview-limit 2000" in cmd
+    assert "tail -n" not in cmd
+    assert "--preview-limit 2000 '/tmp/a file.jsonl'" in cmd
     assert "LESSSECURE=1" in cmd
     assert "LESSHISTFILE=-" in cmd
     assert "LESSOPEN= LESSCLOSE=" in cmd

{railmux-0.4.0.dev32 → railmux-0.4.0.dev33}/tests/test_focus_highlight.py

@@ -1302,6 +1302,14 @@ def test_preview_targets_explicit_active_secondary_slot():
         session_type="claude",
         slot=app._workspace.secondary,
     )
+    app._set_slot_active_target.assert_called_once_with(
+        app._workspace.secondary,
+        "preview-id",
+        None,
+        mode_key="claude",
+        project_key="project",
+        sync_transcript_source=False,
+    )
     assert app._workspace.secondary.in_history_mode is True
 
 
@@ -1332,7 +1340,111 @@ def test_codex_preview_resolves_newest_rewind_representative():
     app._show_transcript.assert_called_once_with(
         current.jsonl_path, session_type="codex")
     app._set_active_target.assert_called_once_with(
-        "current-id", None, mode_key="codex", project_key="project")
+        "current-id",
+        None,
+        mode_key="codex",
+        project_key="project",
+        sync_transcript_source=False,
+    )
+
+
+def test_repeat_preview_reuses_owned_pane_without_revalidating_chrome(
+    monkeypatch, tmp_path,
+):
+    """The stopped-preview hot path launches only the replacement viewer."""
+    app = App.__new__(App)
+    app._workspace = AgentWorkspace()
+    slot = app._workspace.primary
+    slot.pane_id = "%2"
+    slot.in_history_mode = True
+    slot.agent_tmux_name = None
+    slot.swap_state = None
+    app._less_mouse_flag = ""
+    app._display_transport = MagicMock()
+    app._sync_slot_transcript_source = MagicMock()
+    app._set_divider_active = MagicMock()
+    app._install_tmux_bindings = MagicMock()
+    app._set_status = MagicMock()
+    commands = []
+    monkeypatch.setattr(
+        tmux_ctl,
+        "pane_alive",
+        lambda _pane: pytest.fail("repeat preview must not list every pane"),
+    )
+    monkeypatch.setattr(
+        tmux_ctl,
+        "respawn_pane",
+        lambda pane, command: commands.append((pane, command)) or True,
+    )
+
+    assert app._show_transcript(
+        tmp_path / "next.jsonl", session_type="claude")
+
+    assert len(commands) == 1
+    assert commands[0][0] == "%2"
+    app._display_transport.assert_not_called()
+    app._sync_slot_transcript_source.assert_not_called()
+    app._set_divider_active.assert_not_called()
+    app._install_tmux_bindings.assert_not_called()
+
+
+def test_repeat_preview_respawn_failure_keeps_safe_existing_state(
+    monkeypatch, tmp_path,
+):
+    app = App.__new__(App)
+    app._workspace = AgentWorkspace()
+    slot = app._workspace.primary
+    slot.pane_id = "%2"
+    slot.in_history_mode = True
+    slot.agent_tmux_name = None
+    slot.swap_state = None
+    app._less_mouse_flag = ""
+    app._display_transport = MagicMock()
+    app._sync_slot_transcript_source = MagicMock()
+    app._set_divider_active = MagicMock()
+    app._install_tmux_bindings = MagicMock()
+    app._set_status = MagicMock()
+    monkeypatch.setattr(tmux_ctl, "respawn_pane", lambda *_args: False)
+
+    assert not app._show_transcript(
+        tmp_path / "missing.jsonl", session_type="claude")
+
+    assert slot.pane_id == "%2"
+    assert slot.in_history_mode is True
+    app._display_transport.assert_not_called()
+    app._sync_slot_transcript_source.assert_not_called()
+    app._set_status.assert_called_once_with(
+        "failed to respawn right pane for transcript")
+
+
+def test_repeat_preview_with_inconsistent_transport_uses_full_safety_path(
+    monkeypatch, tmp_path,
+):
+    app = App.__new__(App)
+    app._workspace = AgentWorkspace()
+    slot = app._workspace.primary
+    slot.pane_id = "%2"
+    slot.in_history_mode = True
+    slot.agent_tmux_name = None
+    slot.swap_state = None
+    slot.transport_kind = DisplayTransportKind.SWAP
+    app._less_mouse_flag = ""
+    transport = MagicMock()
+    transport.prepare_preview.return_value = True
+    app._display_transport = MagicMock(return_value=transport)
+    app._sync_slot_transcript_source = MagicMock()
+    app._set_divider_active = MagicMock()
+    app._install_tmux_bindings = MagicMock()
+    app._set_status = MagicMock()
+    monkeypatch.setattr(tmux_ctl, "respawn_pane", lambda *_args: True)
+
+    assert app._show_transcript(
+        tmp_path / "next.jsonl", session_type="claude")
+
+    transport.prepare_preview.assert_called_once_with(slot)
+    app._sync_slot_transcript_source.assert_called_once_with(slot, None, None)
+    app._set_divider_active.assert_called_once_with(False, force=True)
+    app._install_tmux_bindings.assert_called_once_with()
 
 
 def test_private_history_restore_key_routes_exact_slot_before_modal_checks():
@@ -1357,8 +1469,9 @@ def test_live_transcript_viewer_exit_signals_exact_slot_restore(
     app._less_mouse_flag = ""
     app._railmux_pane_id = "%1"
     app._railmux_has_focus = True
-    app._display_transport = MagicMock(
-        return_value=SimpleNamespace(prepare_preview=lambda _slot: True))
+    transport = MagicMock()
+    transport.prepare_preview.return_value = True
+    app._display_transport = MagicMock(return_value=transport)
     app._sync_slot_transcript_source = MagicMock()
     app._set_divider_active = MagicMock()
     app._install_tmux_bindings = MagicMock()
@@ -1377,6 +1490,10 @@ def test_live_transcript_viewer_exit_signals_exact_slot_restore(
     assert "tmux send-keys -l -t %1" in commands[0][1]
     assert "\x1b[42~" in commands[0][1]
     assert slot.agent_tmux_name is None
+    transport.prepare_preview.assert_called_once_with(slot)
+    app._sync_slot_transcript_source.assert_called_once_with(slot, None, None)
+    app._set_divider_active.assert_called_once_with(False, force=True)
+    app._install_tmux_bindings.assert_called_once_with()
 
 
 def test_closed_live_history_restores_saved_agent_to_same_slot(monkeypatch):

{railmux-0.4.0.dev32 → railmux-0.4.0.dev33}/tests/test_tmux_integration.py

@@ -160,6 +160,72 @@ def _require_tmux(minimum: tuple[int, int], feature: str) -> None:
         )
 
 
+def test_real_transcript_preview_respawns_one_owned_pane(
+    isolated_tmux, tmp_path,
+):
+    """Exercise the no-tail viewer and its repeat-preview tmux primitive."""
+    if shutil.which("less") is None:
+        pytest.skip("less is not installed")
+    _session_name, controller_pane, socket_path = isolated_tmux
+    first = tmp_path / "first.jsonl"
+    second = tmp_path / "second.jsonl"
+    first.write_text(
+        '{"type":"user","message":{"role":"user",'
+        '"content":"first-preview"}}\n',
+        encoding="utf-8",
+    )
+    second.write_text(
+        '{"type":"user","message":{"role":"user",'
+        '"content":"second-preview"}}\n',
+        encoding="utf-8",
+    )
+
+    def viewer(path: Path) -> str:
+        producer = shlex.join((
+            sys.executable,
+            "-m",
+            "railmux.transcript",
+            "--format",
+            "claude",
+            "--preview-limit",
+            "2000",
+            str(path),
+        ))
+        return (
+            f"{producer} | LESSSECURE=1 LESSHISTFILE=- "
+            "LESSOPEN= LESSCLOSE= less -R +G"
+        )
+
+    pane_id = subprocess.check_output(
+        [
+            "tmux", "-S", socket_path, "split-window", "-d", "-h",
+            "-P", "-F", "#{pane_id}", "-t", controller_pane,
+            viewer(first),
+        ],
+        text=True,
+    ).strip()
+
+    def pane_contains(value: str) -> bool:
+        capture = subprocess.run(
+            ["tmux", "-S", socket_path, "capture-pane", "-p", "-t", pane_id],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        return capture.returncode == 0 and value in capture.stdout
+
+    assert _wait_until(lambda: pane_contains("first-preview"))
+    subprocess.run(
+        [
+            "tmux", "-S", socket_path, "respawn-pane", "-k", "-t", pane_id,
+            viewer(second),
+        ],
+        check=True,
+    )
+    assert _wait_until(lambda: pane_contains("second-preview"))
+    assert not pane_contains("first-preview")
+
+
 def test_real_transparent_windows_relay_attaches_and_detaches(isolated_tmux):
     session_name, _pane_id, socket_path = isolated_tmux
     target = TmuxServerTarget(

{railmux-0.4.0.dev32 → railmux-0.4.0.dev33}/tests/test_transcript.py

@@ -11,6 +11,7 @@ from railmux.transcript import (
     BOLD,
     CLAUDE_ACCENT,
     RESET,
+    _tail_utf8_lines,
     _is_real_user,
     _render_user,
     _render_assistant_blocks,
@@ -612,6 +613,43 @@ def test_main_preview_banner_and_footer(tmp_path, capsys):
     assert "/ search" in output and "q close" in output
 
 
+def test_tail_utf8_lines_reads_complete_final_records_across_blocks(tmp_path):
+    jsonl = tmp_path / "large.jsonl"
+    long_line = "older-" + "x" * 70_000
+    jsonl.write_text(
+        "\n".join((long_line, "保留一", "保留二", "保留三")),
+        encoding="utf-8",
+    )
+
+    stream = _tail_utf8_lines(jsonl, 3)
+
+    assert stream.read().splitlines() == ["保留一", "保留二", "保留三"]
+
+
+def test_main_preview_limit_bounds_a_direct_file_without_external_tail(
+    tmp_path, capsys,
+):
+    jsonl = tmp_path / "claude.jsonl"
+    _write_jsonl(jsonl, [
+        {
+            "type": "user",
+            "message": {"role": "user", "content": f"message-{index}"},
+        }
+        for index in range(5)
+    ])
+
+    main([
+        "transcript", "--format", "claude", "--preview-limit", "2",
+        str(jsonl),
+    ])
+
+    output = capsys.readouterr().out
+    assert "message-0" not in output
+    assert "message-2" not in output
+    assert "message-3" in output
+    assert "message-4" in output
+
+
 def test_main_rejects_bad_preview_limit(capsys):
     with pytest.raises(SystemExit) as exc:
         main(["transcript", "--preview-limit", "nope", "-"])

railmux-0.4.0.dev32/src/railmux/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.4.0.dev32"