railmux 0.4.0.dev31__tar.gz → 0.4.0.dev33__tar.gz

{railmux-0.4.0.dev31/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.dev31
+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.dev31 → 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.dev31 → 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(
@@ -2035,21 +2040,35 @@ class App:
 
     # --- history preview (display pane shows a transcript, not an agent session) ---
 
+    def _paint_session_row_click_now(self, session_id: str | None) -> None:
+        """Acknowledge a pointer selection before synchronous tmux work."""
+        pane = getattr(self, "_sessions_pane", None)
+        if pane is None:
+            return
+        pane.set_selected_session(session_id)
+        loop = getattr(self, "_loop", None)
+        if loop is not None:
+            loop.draw_screen()
+
     def _on_session_row_preview(self, session: SessionMeta) -> None:
         """Apply click semantics after rechecking whether the row is live."""
-        running = self._by_session_id(session.session_id)
-        if (running is not None
-                and self._agent_session_alive(running.tmux_name)):
-            self._on_running_select(
-                RunningEntry(
-                    tmux_name=running.tmux_name,
-                    label=running.label,
-                    status=running.status,
-                ),
-                steal_focus=False,
-            )
-            return
-        self._on_session_preview(session)
+        self._paint_session_row_click_now(session.session_id)
+        try:
+            running = self._by_session_id(session.session_id)
+            if (running is not None
+                    and self._agent_session_alive(running.tmux_name)):
+                self._on_running_select(
+                    RunningEntry(
+                        tmux_name=running.tmux_name,
+                        label=running.label,
+                        status=running.status,
+                    ),
+                    steal_focus=False,
+                )
+                return
+            self._on_session_preview(session)
+        finally:
+            self._paint_session_row_click_now(None)
 
     def _on_session_preview(self, session: SessionMeta) -> None:
         """Show the provider's canonical current-branch history.
@@ -2090,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)")
@@ -2183,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)
@@ -2196,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)
@@ -2211,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.dev31 → railmux-0.4.0.dev33}/src/railmux/windows_bootstrap.py

@@ -20,6 +20,7 @@ from railmux.windows_msys2 import (
     plan_managed_runtime_prune,
     reusable_managed_base_candidate,
 )
+from railmux.windows_paths import managed_windows_data_root
 
 
 _MINIMUM_WINDOWS_PYTHON = (3, 10)
@@ -49,6 +50,14 @@ def _runtime_status(
 ) -> int:
     snapshot = managed_runtime_status(
         version=__version__, environ=environ, verify=verify)
+    data_root = (
+        managed_windows_data_root(environ)
+        if runtime is None or runtime.managed
+        else None
+    )
+    if data_root is not None:
+        snapshot["data_root"] = str(data_root)
+        snapshot["log_directory"] = str(data_root / "logs")
     if json_output:
         json.dump(snapshot, sys.stdout, indent=2, sort_keys=True)
         print()
@@ -75,6 +84,9 @@ def _runtime_status(
         if root is not None:
             print(f"Managed location: {root}")
         print("Next: run 'railmux runtime install' from an interactive PowerShell.")
+    if data_root is not None:
+        print(f"Data root: {data_root}")
+        print(f"Install logs: {data_root / 'logs'}")
     print("Provider data: shared from the Windows user profile")
     content = snapshot.get("content_identity")
     if isinstance(content, str):

{railmux-0.4.0.dev31 → railmux-0.4.0.dev33}/src/railmux/windows_install_log.py

@@ -162,7 +162,12 @@ class InstallReporter:
 
     def __enter__(self) -> InstallReporter:
         self.path.parent.mkdir(parents=True, exist_ok=True)
-        self._log = self.path.open("x", encoding="utf-8", newline="\n")
+        # Windows PowerShell 5 treats BOM-less UTF-8 as the active ANSI code
+        # page.  The signature keeps Chinese systems from rendering the
+        # middle dot/ellipsis as mojibake while remaining ordinary UTF-8 for
+        # modern readers (use ``utf-8-sig`` when the exact first character
+        # matters).
+        self._log = self.path.open("x", encoding="utf-8-sig", newline="\n")
         self._write_log("Railmux Windows runtime installation\n")
         # Windows may defer the visible last-write timestamp of an open file.
         # Never let retention mistake the active evidence log for an old one.