railmux 0.4.0.dev8__tar.gz → 0.4.0.dev9__tar.gz

{railmux-0.4.0.dev8/src/railmux.egg-info → railmux-0.4.0.dev9}/PKG-INFO

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

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

{railmux-0.4.0.dev8 → railmux-0.4.0.dev9}/src/railmux/cli.py

@@ -24,12 +24,15 @@ from railmux.system_deps import ensure_tmux_available
 from railmux.ssh_args import AppendSshArgument, ExtendSshArguments
 
 
-def _show_startup_message() -> None:
+def _show_startup_message(
+    detail: str = "Reconnecting sessions and panes…",
+) -> None:
     """Paint immediate feedback before App performs its initial discovery."""
     if not sys.stdout.isatty():
         return
     size = shutil.get_terminal_size((80, 24))
-    sys.stdout.write(render_startup_surface(size.columns, size.lines))
+    sys.stdout.write(render_startup_surface(
+        size.columns, size.lines, detail=detail))
     sys.stdout.flush()
 
 
@@ -441,6 +444,7 @@ def main(argv: list[str] | None = None) -> int:
     _show_startup_message()
     # Lazy import so non-TUI invocations (--version etc) don't pull urwid.
     from railmux.ui.app import App
+    from railmux.provider_paths import running_in_windows_wrapper
     app = App(
         claude_home=Path(args.claude_home),
         config=config,
@@ -451,6 +455,10 @@ def main(argv: list[str] | None = None) -> int:
             is_ssh_session() if args.scroll_coalescing is None
             else args.scroll_coalescing
         ),
+        startup_progress=(
+            _show_startup_message
+            if running_in_windows_wrapper() else None
+        ),
     )
     app.run()
     return 0

{railmux-0.4.0.dev8 → railmux-0.4.0.dev9}/src/railmux/discovery.py

@@ -1,8 +1,10 @@
 """Enumerate Claude project directories from ~/.claude/projects/."""
 from __future__ import annotations
 
+import hashlib
 import json
 import os
+import stat
 from pathlib import Path
 
 from railmux.atomic_file import atomic_write_text
@@ -19,6 +21,134 @@ _cache: dict[Path, tuple[int, list[Project]]] = {}
 _session_validity: dict[
     Path, dict[Path, tuple[tuple[int, int, int], bool]]
 ] = {}
+_persistent_validity_loaded: set[Path] = set()
+_persistent_validity_exact_only: set[Path] = set()
+_persistent_validity_dirty: set[Path] = set()
+_VALIDITY_CACHE_SCHEMA = 1
+_VALIDITY_CACHE_LIMIT = 16 * 1024 * 1024
+_VALIDITY_RECORD_LIMIT = 100_000
+
+
+def _windows_validity_cache_enabled() -> bool:
+    return os.environ.get("RAILMUX_WINDOWS_RUNTIME") == "msys2"
+
+
+def _validity_cache_file(claude_home: Path) -> Path:
+    base = Path(os.environ.get("XDG_CACHE_HOME", Path.home() / ".cache"))
+    identity = hashlib.sha256(
+        os.fsencode(os.path.abspath(claude_home))
+    ).hexdigest()[:16]
+    return base / "railmux" / f"claude-validity-{identity}.json"
+
+
+def _load_persistent_validity(claude_home: Path) -> None:
+    if (
+        not _windows_validity_cache_enabled()
+        or claude_home in _persistent_validity_loaded
+    ):
+        return
+    _persistent_validity_loaded.add(claude_home)
+    path = _validity_cache_file(claude_home)
+    try:
+        info = path.lstat()
+        if (
+            not stat.S_ISREG(info.st_mode)
+            or info.st_uid != os.getuid()
+            or info.st_size > _VALIDITY_CACHE_LIMIT
+            or info.st_mode & 0o077
+        ):
+            return
+        raw = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError):
+        return
+    if not isinstance(raw, dict) or raw.get("schema") != _VALIDITY_CACHE_SCHEMA:
+        return
+    records = raw.get("records")
+    if not isinstance(records, list) or len(records) > _VALIDITY_RECORD_LIMIT:
+        return
+    projects_dir = claude_home / "projects"
+    loaded: list[Path] = []
+    try:
+        for record in records:
+            if not isinstance(record, list) or len(record) != 6:
+                raise ValueError("invalid validity record")
+            project, filename, inode, mtime_ns, size, valid = record
+            if (
+                not isinstance(project, str)
+                or not is_encoded_project_name(project)
+                or not isinstance(filename, str)
+                or Path(filename).name != filename
+                or not filename.endswith(".jsonl")
+                or not _looks_like_uuid(Path(filename).stem)
+                or not all(isinstance(value, int) and value >= 0
+                           for value in (inode, mtime_ns, size))
+                or not isinstance(valid, bool)
+            ):
+                raise ValueError("invalid validity record")
+            project_dir = projects_dir / project
+            session_path = project_dir / filename
+            _session_validity.setdefault(project_dir, {})[session_path] = (
+                (inode, mtime_ns, size), valid,
+            )
+            loaded.append(session_path)
+    except ValueError:
+        for session_path in loaded:
+            cached = _session_validity.get(session_path.parent)
+            if cached is not None:
+                cached.pop(session_path, None)
+                if not cached:
+                    _session_validity.pop(session_path.parent, None)
+        return
+    _persistent_validity_exact_only.update(loaded)
+
+
+def _mark_persistent_validity_dirty(claude_dir: Path) -> None:
+    if _windows_validity_cache_enabled():
+        _persistent_validity_dirty.add(claude_dir.parent.parent)
+
+
+def _save_persistent_validity(claude_home: Path) -> None:
+    if (
+        not _windows_validity_cache_enabled()
+        or claude_home not in _persistent_validity_dirty
+    ):
+        return
+    projects_dir = claude_home / "projects"
+    records: list[list[object]] = []
+    for project_dir, values in _session_validity.items():
+        if (
+            project_dir.parent != projects_dir
+            or not is_encoded_project_name(project_dir.name)
+        ):
+            continue
+        for session_path, (signature, valid) in values.items():
+            if session_path.parent != project_dir:
+                continue
+            inode, mtime_ns, size = signature
+            records.append([
+                project_dir.name,
+                session_path.name,
+                inode,
+                mtime_ns,
+                size,
+                valid,
+            ])
+    records.sort(key=lambda item: int(item[3]), reverse=True)
+    records = records[:_VALIDITY_RECORD_LIMIT]
+    path = _validity_cache_file(claude_home)
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        atomic_write_text(
+            path,
+            json.dumps(
+                {"schema": _VALIDITY_CACHE_SCHEMA, "records": records},
+                separators=(",", ":"),
+            ),
+        )
+        os.chmod(path, 0o600)
+    except OSError:
+        return
+    _persistent_validity_dirty.discard(claude_home)
 
 
 def invalidate_session(path: Path) -> None:
@@ -27,6 +157,8 @@ def invalidate_session(path: Path) -> None:
     if cached is None:
         return
     cached.pop(path, None)
+    _persistent_validity_exact_only.discard(path)
+    _mark_persistent_validity_dirty(path.parent)
     if not cached:
         _session_validity.pop(path.parent, None)
 
@@ -64,6 +196,7 @@ def list_projects(claude_home: Path) -> list[Project]:
     session counts and recency track files created, changed, or removed below
     the cached top-level directory.
     """
+    _load_persistent_validity(claude_home)
     projects_dir = claude_home / "projects"
     if not projects_dir.is_dir():
         return []
@@ -79,6 +212,7 @@ def list_projects(claude_home: Path) -> list[Project]:
         # without re-decoding every project name.
         refreshed = _refresh_activity(cached[1])
         _cache[claude_home] = (parent_mtime, refreshed)
+        _save_persistent_validity(claude_home)
         return refreshed
 
     # Full scan needed.
@@ -153,6 +287,7 @@ def list_projects(claude_home: Path) -> list[Project]:
 
     results.sort(key=lambda p: p.last_activity_ts, reverse=True)
     _cache[claude_home] = (parent_mtime, results)
+    _save_persistent_validity(claude_home)
     return results
 
 
@@ -198,6 +333,7 @@ def _count_and_latest_mtime(claude_dir: Path, real_path: Path) -> tuple[int, flo
             if cached is not None and cached[0] == signature:
                 valid = cached[1]
             elif (cached is not None and cached[1]
+                  and path not in _persistent_validity_exact_only
                   and cached[0][0] == stat.st_ino
                   and stat.st_size > cached[0][2]):
                 # Claude session JSONLs are append-only. Once a file is valid,
@@ -208,9 +344,12 @@ def _count_and_latest_mtime(claude_dir: Path, real_path: Path) -> tuple[int, flo
                 # explicitly via ``invalidate_session``).
                 valid = True
                 validity[path] = (signature, True)
+                _mark_persistent_validity_dirty(claude_dir)
             else:
                 valid = _scan_session(temp_project, path) is not None
                 validity[path] = (signature, valid)
+                _persistent_validity_exact_only.discard(path)
+                _mark_persistent_validity_dirty(claude_dir)
             if not valid:
                 continue
             count += 1
@@ -219,6 +358,8 @@ def _count_and_latest_mtime(claude_dir: Path, real_path: Path) -> tuple[int, flo
                 latest = m
     for stale in set(validity) - current_paths:
         del validity[stale]
+        _persistent_validity_exact_only.discard(stale)
+        _mark_persistent_validity_dirty(claude_dir)
     if not validity:
         _session_validity.pop(claude_dir, None)
     return count, latest

{railmux-0.4.0.dev8 → railmux-0.4.0.dev9}/src/railmux/tmux_binding_manager.py

@@ -14,8 +14,14 @@ from railmux import restart_state, tmux_ctl
 from railmux.atomic_file import atomic_write_text
 
 
-_VERSION = 8
+_VERSION = 9
 _KEYS = ("F8", "F9")
+_STATUS_CLICK_KEYS = (
+    "MouseDown1Status",
+    "MouseDown1Control0",
+    "MouseDown1Control1",
+    "MouseDown1Control2",
+)
 _MAX_STATE_BYTES = 64 * 1024
 
 
@@ -114,12 +120,18 @@ class SharedTmuxBindingManager:
             and all(value is None or isinstance(value, str)
                     for value in right_click_backup.values())
         )
-        status_click_valid = (
+        legacy_status_click_valid = (
             isinstance(status_click_backup, dict)
             and set(status_click_backup) == {"MouseDown1Status"}
             and all(value is None or isinstance(value, str)
                     for value in status_click_backup.values())
         )
+        status_click_valid = (
+            isinstance(status_click_backup, dict)
+            and set(status_click_backup) == set(_STATUS_CLICK_KEYS)
+            and all(value is None or isinstance(value, str)
+                    for value in status_click_backup.values())
+        )
         termux_tap_valid = (
             isinstance(termux_tap_backup, dict)
             and set(termux_tap_backup) == {"MouseDown1Pane"}
@@ -149,7 +161,13 @@ class SharedTmuxBindingManager:
                          or (not selection_hook_managed
                              and selection_hook_index is not None)))
                 or (raw["version"] >= 5
-                    and (not status_click_valid
+                    and ((raw["version"] < 9
+                          and not (
+                              legacy_status_click_valid
+                              or status_click_valid
+                          ))
+                         or (raw["version"] >= 9
+                             and not status_click_valid)
                          or not isinstance(status_click_managed, bool)))
                 or (raw["version"] >= 8
                     and (not termux_tap_valid
@@ -293,6 +311,29 @@ class SharedTmuxBindingManager:
                             or {"MouseDown1Pane": None}
                         )
                         upgraded = True
+                    if state["version"] < 9:
+                        if state["status_click_managed"]:
+                            if set(state["status_click_backup"]) != set(
+                                _STATUS_CLICK_KEYS
+                            ):
+                                status_click_backup = (
+                                    tmux_ctl.upgrade_root_status_click_binding(
+                                        state["status_click_backup"],
+                                        state["token"],
+                                    )
+                                )
+                                if status_click_backup is None:
+                                    return False
+                                state["status_click_backup"] = (
+                                    status_click_backup)
+                        else:
+                            state["status_click_backup"] = {
+                                key: None for key in _STATUS_CLICK_KEYS
+                            }
+                        # tmux 3.7 routes control ranges through dedicated
+                        # MouseDown1ControlN keys. Capture all originals before
+                        # reinstalling the shared status-click lease.
+                        upgraded = True
                     if upgraded:
                         state["version"] = _VERSION
                         state["phase"] = "installing"
@@ -341,17 +382,14 @@ class SharedTmuxBindingManager:
                             )
                         if state["status_click_managed"]:
                             current_status = (
-                                tmux_ctl.read_root_status_click_binding()
-                                ["MouseDown1Status"]
-                            )
-                            safe = (
-                                safe
-                                and tmux_ctl.root_status_click_binding_is_original_or_owned(
-                                    current_status,
-                                    state["status_click_backup"].get(
-                                        "MouseDown1Status"),
+                                tmux_ctl.read_root_status_click_binding())
+                            safe = safe and all(
+                                tmux_ctl.root_status_click_binding_is_original_or_owned(
+                                    current_status.get(key),
+                                    state["status_click_backup"].get(key),
                                     token,
                                 )
+                                for key in _STATUS_CLICK_KEYS
                             )
                         if state["termux_tap_managed"]:
                             current_tap = (
@@ -543,7 +581,8 @@ class SharedTmuxBindingManager:
                     "selection_hook_index": selection_hook_index,
                     "status_click_managed": status_click_backup is not None,
                     "status_click_backup": (
-                        status_click_backup or {"MouseDown1Status": None}),
+                        status_click_backup
+                        or {key: None for key in _STATUS_CLICK_KEYS}),
                     "termux_tap_managed": termux_tap_backup is not None,
                     "termux_tap_backup": (
                         termux_tap_backup or {"MouseDown1Pane": None}),

{railmux-0.4.0.dev8 → railmux-0.4.0.dev9}/src/railmux/tmux_ctl.py

@@ -1815,6 +1815,15 @@ _ROOT_TERMUX_TAP_MARKER = "railmux-termux-tap-v1"
 STATUS_ACTION_MODE = "railmux-mode"
 STATUS_ACTION_LAYOUT = "railmux-layout"
 STATUS_ACTION_COPY = "railmux-copy"
+_ROOT_STATUS_ACTION_KEYS = {
+    STATUS_ACTION_MODE: "MouseDown1Control0",
+    STATUS_ACTION_LAYOUT: "MouseDown1Control1",
+    STATUS_ACTION_COPY: "MouseDown1Control2",
+}
+_ROOT_STATUS_CLICK_KEYS = (
+    _ROOT_STATUS_CLICK_KEY,
+    *_ROOT_STATUS_ACTION_KEYS.values(),
+)
 _STATUS_ACTIONS = frozenset({
     STATUS_ACTION_MODE,
     STATUS_ACTION_LAYOUT,
@@ -1897,6 +1906,14 @@ def status_action_range(action: str, content: str) -> str:
         raise ValueError(f"invalid Railmux status action: {action!r}")
     if not status_pane_ranges_supported():
         return content
+    # tmux 3.7 gives control ranges distinct root-table mouse keys. Using those
+    # keys avoids routing fixed actions through the generic user-range
+    # dispatcher and provides deterministic bindings on the 3.7b version
+    # bundled by the managed Windows runtime.
+    if tmux_version() >= (3, 7):
+        key = _ROOT_STATUS_ACTION_KEYS[action]
+        index = key.removeprefix("MouseDown1Control")
+        return f"#[range=control|{index}]{content}#[norange]"
     return f"#[range=user|{action}]{content}#[norange]"
 
 
@@ -2752,27 +2769,100 @@ def restore_root_termux_tap_binding(
 
 
 def read_root_status_click_binding() -> RootStatusClickBindingBackup:
-    """Capture the root binding used for pane ranges in the status line."""
+    """Capture every root binding used by status ranges and controls."""
     return {
-        _ROOT_STATUS_CLICK_KEY:
-        _read_key_binding("root", _ROOT_STATUS_CLICK_KEY),
+        key: _read_key_binding("root", key)
+        for key in _ROOT_STATUS_CLICK_KEYS
     }
 
 
+def _status_click_backup_replayable(
+    backup: RootStatusClickBindingBackup,
+) -> bool:
+    if set(backup) != set(_ROOT_STATUS_CLICK_KEYS):
+        return False
+    for binding in backup.values():
+        if binding is None:
+            continue
+        try:
+            _binding_command(binding)
+        except ValueError:
+            return False
+    return True
+
+
 def prepare_root_status_click_binding() -> RootStatusClickBindingBackup | None:
     """Return a replayable status-click binding, or decline management."""
     if not status_pane_ranges_supported():
         return None
     backup = read_root_status_click_binding()
-    binding = backup[_ROOT_STATUS_CLICK_KEY]
-    if binding and _ROOT_STATUS_CLICK_MARKER in binding:
+    if any(
+        binding and _ROOT_STATUS_CLICK_MARKER in binding
+        for binding in backup.values()
+    ):
         return None
-    if binding is not None:
-        try:
-            _binding_command(binding)
-        except ValueError:
-            return None
-    return backup
+    return backup if _status_click_backup_replayable(backup) else None
+
+
+def upgrade_root_status_click_binding(
+    previous: RootStatusClickBindingBackup,
+    token: str,
+) -> RootStatusClickBindingBackup | None:
+    """Expand a pre-control-range lease without losing user bindings.
+
+    Versions 5-8 saved only MouseDown1Status.  Before version 9 installs the
+    tmux 3.7 control keys it captures their exact current commands, while also
+    verifying that the old status wrapper is still either original or ours.
+    """
+    if set(previous) != {_ROOT_STATUS_CLICK_KEY}:
+        return None
+    current = read_root_status_click_binding()
+    if not root_status_click_binding_is_original_or_owned(
+        current.get(_ROOT_STATUS_CLICK_KEY),
+        previous.get(_ROOT_STATUS_CLICK_KEY),
+        token,
+    ):
+        return None
+    upgraded = dict(current)
+    upgraded[_ROOT_STATUS_CLICK_KEY] = previous[_ROOT_STATUS_CLICK_KEY]
+    return upgraded if _status_click_backup_replayable(upgraded) else None
+
+
+def _status_click_fallback(binding: str | None) -> str:
+    return _binding_command(binding) if binding is not None else 'run-shell "true"'
+
+
+def _set_root_status_control_forwarding(
+    backup: RootStatusClickBindingBackup,
+    token: str,
+) -> None:
+    if tmux_version() < (3, 7):
+        return
+    marker = f"{_ROOT_STATUS_CLICK_MARKER}-{token}"
+    action_keys = {
+        STATUS_ACTION_MODE: "F5",
+        STATUS_ACTION_LAYOUT: "F7",
+        STATUS_ACTION_COPY: "F6",
+    }
+    condition = (
+        "#{&&:"
+        f"#{{!=:#{{{RAILMUX_CONTROLLER_OPTION}}},}},"
+        f"#{{==:{marker},{marker}}}}}"
+    )
+    for action, key in _ROOT_STATUS_ACTION_KEYS.items():
+        dispatch = (
+            f"run-shell \"{_tmux_shell_executable()} send-keys -t "
+            f"'#{{{RAILMUX_CONTROLLER_OPTION}}}' {action_keys[action]}\""
+        )
+        subprocess.check_call(
+            [
+                "tmux", "bind-key", "-T", "root", key,
+                "if-shell", "-F", condition, dispatch,
+                _status_click_fallback(backup.get(key)),
+            ],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
 
 
 def set_root_status_click_forwarding(
@@ -2781,6 +2871,8 @@ def set_root_status_click_forwarding(
     """Dispatch Railmux user ranges and replay all other status clicks."""
     if not status_pane_ranges_supported():
         return False
+    if not _status_click_backup_replayable(backup):
+        return False
     marker = f"{_ROOT_STATUS_CLICK_MARKER}-{token}"
     condition = (
         "#{&&:"
@@ -2791,10 +2883,7 @@ def set_root_status_click_forwarding(
     )
     original = backup.get(_ROOT_STATUS_CLICK_KEY)
     try:
-        fallback = (
-            _binding_command(original)
-            if original is not None else 'run-shell "true"'
-        )
+        fallback = _status_click_fallback(original)
         dispatch = (
             'run-shell "case \'#{mouse_status_range}\' in '
             f'%*) {_tmux_shell_executable()} select-pane -Z -t '
@@ -2820,21 +2909,33 @@ def set_root_status_click_forwarding(
             stdout=subprocess.DEVNULL,
             stderr=subprocess.DEVNULL,
         )
+        _set_root_status_control_forwarding(backup, token)
         return True
     except (ValueError, subprocess.CalledProcessError, FileNotFoundError):
+        # A later control-key write can fail after MouseDown1Status was
+        # installed. Restore only bindings bearing this lease's marker.
+        restore_root_status_click_binding(backup, token=token)
         return False
 
 
 def root_status_click_binding_owned_by(token: str) -> bool:
     marker = f"{_ROOT_STATUS_CLICK_MARKER}-{token}"
-    binding = read_root_status_click_binding().get(_ROOT_STATUS_CLICK_KEY)
-    return bool(
-        binding
-        and marker in binding
+    current = read_root_status_click_binding()
+    binding = current.get(_ROOT_STATUS_CLICK_KEY)
+    base_owned = bool(
+        binding and marker in binding
         and RAILMUX_CONTROLLER_OPTION in binding
         and "mouse_status_range" in binding
         and "select-pane -Z -t" in binding
     )
+    if not base_owned or tmux_version() < (3, 7):
+        return base_owned
+    return all(
+        (binding := current.get(key)) is not None
+        and marker in binding
+        and RAILMUX_CONTROLLER_OPTION in binding
+        for key in _ROOT_STATUS_ACTION_KEYS.values()
+    )
 
 
 def root_status_click_binding_is_original_or_owned(
@@ -2851,35 +2952,36 @@ def root_status_click_binding_is_original_or_owned(
 def restore_root_status_click_binding(
     backup: RootStatusClickBindingBackup, *, token: str,
 ) -> None:
-    """Restore MouseDown1Status only while the live wrapper is still ours."""
-    live = read_root_status_click_binding().get(_ROOT_STATUS_CLICK_KEY)
+    """Restore status bindings only while each live wrapper is still ours."""
+    live = read_root_status_click_binding()
     marker = f"{_ROOT_STATUS_CLICK_MARKER}-{token}"
-    if live is None or marker not in live:
-        return
-    original = backup.get(_ROOT_STATUS_CLICK_KEY)
-    try:
-        if original is None:
-            subprocess.check_call(
-                ["tmux", "unbind-key", "-T", "root",
-                 _ROOT_STATUS_CLICK_KEY],
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
-            )
-        else:
-            fd, path = tempfile.mkstemp(
-                prefix="railmux-root-status-click-", suffix=".conf")
-            try:
-                with os.fdopen(fd, "w", encoding="utf-8") as fh:
-                    fh.write(original + "\n")
+    for key in _ROOT_STATUS_CLICK_KEYS:
+        current = live.get(key)
+        if current is None or marker not in current:
+            continue
+        original = backup.get(key)
+        try:
+            if original is None:
                 subprocess.check_call(
-                    ["tmux", "source-file", path],
+                    ["tmux", "unbind-key", "-T", "root", key],
                     stdout=subprocess.DEVNULL,
                     stderr=subprocess.DEVNULL,
                 )
-            finally:
-                os.unlink(path)
-    except (OSError, subprocess.CalledProcessError, FileNotFoundError):
-        pass
+            else:
+                fd, path = tempfile.mkstemp(
+                    prefix="railmux-root-status-click-", suffix=".conf")
+                try:
+                    with os.fdopen(fd, "w", encoding="utf-8") as fh:
+                        fh.write(original + "\n")
+                    subprocess.check_call(
+                        ["tmux", "source-file", path],
+                        stdout=subprocess.DEVNULL,
+                        stderr=subprocess.DEVNULL,
+                    )
+                finally:
+                    os.unlink(path)
+        except (OSError, subprocess.CalledProcessError, FileNotFoundError):
+            pass
 
 
 def read_prefix_target_binding() -> PrefixTargetBindingBackup: