railmux 0.4.0.dev14__tar.gz → 0.4.0.dev16__tar.gz

{railmux-0.4.0.dev14/src/railmux.egg-info → railmux-0.4.0.dev16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.0.dev14
+Version: 0.4.0.dev16
 Summary: Terminal UI to navigate, resume, and start Claude Code and Codex sessions
 Author-email: Rightglow <zhang.taian@foxmail.com>
 License-Expression: MIT
@@ -170,7 +170,7 @@ for focus and layout limits.
 |--------|--------|
 | Left-click (non-running) | Preview session history in the Target pane |
 | Left-click (running) | Switch the Target pane to that session |
-| Wheel up over a live agent | Open its canonical current-branch history |
+| Wheel over a live agent | Scroll its live terminal history (native locally, Railmux-managed over `railmux ssh`) |
 | Double-click | Open/attach in the Target pane and move focus there |
 | Right-click | Context menu (Open, Preview, Info, Rename, Star, Copy title, Kill, Term, Delete) |
 
@@ -373,16 +373,21 @@ sessions move ahead of the other results.
 
 For a stopped session, left-click or press `␣` to view conversation history in
 the Target pane without starting or resuming the agent. For a running session,
-press `␣`, choose **Preview**, or wheel up over its live pane. Preview is
-read-only: it cannot send a message or change the session. User and assistant
-messages, tool calls, and abbreviated tool output are colour-coded, while
-internal context and encrypted reasoning are hidden. Codex rewind lineages and
-Claude Code `parentUuid` branches are projected onto the provider's current
-conversation: the retained prefix and replacement suffix remain visible, while
-the abandoned suffix is hidden. When Railmux observes a running Codex session
-advance after rewind or steering, it resets only the current terminal view
-before Codex redraws. Retained tmux scrollback is not erased, and managed
-history continues from the canonical rollout without its abandoned suffix.
+press `␣` or choose **Preview**. Preview is read-only: it cannot send a message
+or change the session. User and assistant messages, tool calls, and abbreviated
+tool output are colour-coded, while internal context and encrypted reasoning
+are hidden. Codex rewind lineages and Claude Code `parentUuid` branches are
+projected onto the provider's current conversation: the retained prefix and
+replacement suffix remain visible, while the abandoned suffix is hidden.
+
+Scrolling a live agent does not enter Preview. Direct `railmux` uses the
+terminal/tmux scrolling behavior; `railmux ssh` keeps its own bounded,
+per-pane history and normally preserves the live terminal's captured styling.
+When Railmux confirms that a running Codex session advanced after rewind or
+steering, it resets only the current terminal view before Codex redraws and
+invalidates that pane's SSH history generation. Retained tmux scrollback is not
+erased; the SSH history for that branched generation uses the canonical
+rollout so its abandoned suffix stays hidden.
 
 Preview opens at the latest activity in `less`; large sessions are limited to
 their latest 2,000 saved records. Press `/` to search, `n`/`N` to move between
@@ -423,6 +428,18 @@ Railmux also indexes resumable Claude Code and Codex sessions started outside
 Railmux, so existing conversations appear in the sidebar and resume the same
 way. Non-resumable one-off runs such as `codex exec` are filtered out.
 
+If the same Claude Code or Codex history root is shared across hosts, Railmux
+uses a provider-session lease to prevent two machines from resuming the same
+conversation concurrently. A remotely owned conversation remains in Sessions
+as **running on HOST**, but is not presented as a locally attachable Running
+entry; resume fails safely until that host's exact provider pane exits. The
+lease follows detached agents across Soft Quit and covers every known Codex
+rewind-lineage ID at resume; later rewinds retain a stable locked lineage
+anchor. Delete also checks the shared lease immediately before
+starting and refuses remotely owned history. The shared filesystem must provide
+cross-host POSIX advisory-lock semantics; mounts configured with local-only or
+disabled locking cannot provide this guarantee.
+
 ### Restarts and quitting
 
 Each opened agent runs in a detached tmux session, so switching sessions does

{railmux-0.4.0.dev14 → railmux-0.4.0.dev16}/README.md

@@ -127,7 +127,7 @@ for focus and layout limits.
 |--------|--------|
 | Left-click (non-running) | Preview session history in the Target pane |
 | Left-click (running) | Switch the Target pane to that session |
-| Wheel up over a live agent | Open its canonical current-branch history |
+| Wheel over a live agent | Scroll its live terminal history (native locally, Railmux-managed over `railmux ssh`) |
 | Double-click | Open/attach in the Target pane and move focus there |
 | Right-click | Context menu (Open, Preview, Info, Rename, Star, Copy title, Kill, Term, Delete) |
 
@@ -330,16 +330,21 @@ sessions move ahead of the other results.
 
 For a stopped session, left-click or press `␣` to view conversation history in
 the Target pane without starting or resuming the agent. For a running session,
-press `␣`, choose **Preview**, or wheel up over its live pane. Preview is
-read-only: it cannot send a message or change the session. User and assistant
-messages, tool calls, and abbreviated tool output are colour-coded, while
-internal context and encrypted reasoning are hidden. Codex rewind lineages and
-Claude Code `parentUuid` branches are projected onto the provider's current
-conversation: the retained prefix and replacement suffix remain visible, while
-the abandoned suffix is hidden. When Railmux observes a running Codex session
-advance after rewind or steering, it resets only the current terminal view
-before Codex redraws. Retained tmux scrollback is not erased, and managed
-history continues from the canonical rollout without its abandoned suffix.
+press `␣` or choose **Preview**. Preview is read-only: it cannot send a message
+or change the session. User and assistant messages, tool calls, and abbreviated
+tool output are colour-coded, while internal context and encrypted reasoning
+are hidden. Codex rewind lineages and Claude Code `parentUuid` branches are
+projected onto the provider's current conversation: the retained prefix and
+replacement suffix remain visible, while the abandoned suffix is hidden.
+
+Scrolling a live agent does not enter Preview. Direct `railmux` uses the
+terminal/tmux scrolling behavior; `railmux ssh` keeps its own bounded,
+per-pane history and normally preserves the live terminal's captured styling.
+When Railmux confirms that a running Codex session advanced after rewind or
+steering, it resets only the current terminal view before Codex redraws and
+invalidates that pane's SSH history generation. Retained tmux scrollback is not
+erased; the SSH history for that branched generation uses the canonical
+rollout so its abandoned suffix stays hidden.
 
 Preview opens at the latest activity in `less`; large sessions are limited to
 their latest 2,000 saved records. Press `/` to search, `n`/`N` to move between
@@ -380,6 +385,18 @@ Railmux also indexes resumable Claude Code and Codex sessions started outside
 Railmux, so existing conversations appear in the sidebar and resume the same
 way. Non-resumable one-off runs such as `codex exec` are filtered out.
 
+If the same Claude Code or Codex history root is shared across hosts, Railmux
+uses a provider-session lease to prevent two machines from resuming the same
+conversation concurrently. A remotely owned conversation remains in Sessions
+as **running on HOST**, but is not presented as a locally attachable Running
+entry; resume fails safely until that host's exact provider pane exits. The
+lease follows detached agents across Soft Quit and covers every known Codex
+rewind-lineage ID at resume; later rewinds retain a stable locked lineage
+anchor. Delete also checks the shared lease immediately before
+starting and refuses remotely owned history. The shared filesystem must provide
+cross-host POSIX advisory-lock semantics; mounts configured with local-only or
+disabled locking cannot provide this guarantee.
+
 ### Restarts and quitting
 
 Each opened agent runs in a detached tmux session, so switching sessions does

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

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

{railmux-0.4.0.dev14 → railmux-0.4.0.dev16}/src/railmux/cli.py

@@ -1,11 +1,14 @@
 from __future__ import annotations
 
 import argparse
+import os
 import shutil
 import subprocess
 import sys
 import termios
+import threading
 import time
+import tty
 from dataclasses import replace
 from pathlib import Path
 
@@ -50,7 +53,20 @@ def _restore_terminal(attributes: list | None) -> None:
         pass
 
 
-def _stop_tmux_client(process: subprocess.Popen) -> None:
+def _reset_terminal_modes(fd: int) -> None:
+    """Best-effort recovery when a relay ends before tmux's restore tail."""
+    try:
+        os.write(
+            fd,
+            b"\x1b[?1049l\x1b[?1l\x1b>\x1b[?1000l\x1b[?1002l"
+            b"\x1b[?1003l\x1b[?1004l\x1b[?1006l\x1b[?2004l"
+            b"\x1b[?7h\x1b[?25h\x1b[0m\r",
+        )
+    except OSError:
+        pass
+
+
+def _stop_tmux_client(process: object) -> None:
     if process.poll() is not None:
         return
     process.terminate()
@@ -75,20 +91,43 @@ def _run_tmux_client_with_watchdog(
             attributes = termios.tcgetattr(sys.stdin.fileno())
         except (OSError, termios.error):
             pass
+    started_at = time.monotonic()
     try:
-        process = subprocess.Popen(argv, env=env)
+        process: object = subprocess.Popen(argv, env=env)
     except OSError as exc:
         print(f"error: could not start tmux client: {exc}", file=sys.stderr)
         return 2
-    watchdog = tmux_health.FailureWatchdog.starting(
-        time.monotonic(),
-        interval=_LOCAL_WATCHDOG_INTERVAL,
-        failure_limit=_LOCAL_WATCHDOG_FAILURES,
-    )
-    next_session_probe = watchdog.next_probe - watchdog.interval
-    try:
+    def monitor_client(
+        monitor_started_at: float | None = None,
+        *,
+        asynchronous_probe: bool = False,
+    ) -> tuple[int, bool]:
+        nonlocal expected_target, expected_session_id
+        watchdog = tmux_health.FailureWatchdog.starting(
+            (
+                time.monotonic()
+                if monitor_started_at is None
+                else monitor_started_at
+            ),
+            interval=_LOCAL_WATCHDOG_INTERVAL,
+            failure_limit=_LOCAL_WATCHDOG_FAILURES,
+        )
+        next_session_probe = watchdog.next_probe - watchdog.interval
+        probe_thread: threading.Thread | None = None
+        probe_result: list[tmux_server.TmuxServerTarget | None] = []
+
+        def discover() -> tmux_server.TmuxServerTarget | None:
+            try:
+                return tmux_server.discover_target(timeout=1.0)
+            except tmux_server.TmuxServerError:
+                return None
+
         while process.poll() is None:
-            time.sleep(0.25)
+            pump = getattr(process, "pump", None)
+            if pump is None:
+                time.sleep(0.25)
+            else:
+                pump(0.25)
             now = time.monotonic()
             if (
                 expected_target is not None
@@ -100,10 +139,26 @@ def _run_tmux_client_with_watchdog(
                 next_session_probe = now + 1.0
             if not watchdog.due(now):
                 continue
-            try:
-                current_target = tmux_server.discover_target(timeout=1.0)
-            except tmux_server.TmuxServerError:
-                current_target = None
+            if asynchronous_probe:
+                if probe_thread is None:
+                    probe_result.clear()
+
+                    def run_probe() -> None:
+                        probe_result.append(discover())
+
+                    probe_thread = threading.Thread(
+                        target=run_probe,
+                        name="railmux-tmux-health",
+                        daemon=True,
+                    )
+                    probe_thread.start()
+                    continue
+                if probe_thread.is_alive():
+                    continue
+                current_target = probe_result[0] if probe_result else None
+                probe_thread = None
+            else:
+                current_target = discover()
             if expected_target is None and current_target is not None:
                 expected_target = current_target
                 expected_session_id = tmux_server.target_session_id(
@@ -126,23 +181,94 @@ def _run_tmux_client_with_watchdog(
                     "responding; run 'railmux doctor' for diagnostics",
                     file=sys.stderr,
                 )
-                return 2
+                return 2, True
+        return process.returncode or 0, False
+
+    relay = None
+    relay_attempted = False
+    try:
+        returncode, watchdog_failed = monitor_client(started_at)
+        if watchdog_failed:
+            return returncode
+        failed_at = time.monotonic()
         # tmux may leave the client TTY in raw mode even after its process
         # exits. Restore it before a bounded recovery probe or user message.
         _restore_terminal(attributes)
-        returncode = process.returncode or 0
-        if windows_tmux_lifecycle.recover_abandoned_socket():
-            print(
-                "info: cleaned an abandoned Windows tmux socket; Codex and "
-                "Claude session files were not changed",
-                file=sys.stderr,
-            )
+        current_target = None
         if returncode and expected_target is not None:
             try:
                 current_target = tmux_server.discover_target(timeout=1.0)
             except tmux_server.TmuxServerError:
                 current_target = None
-            if current_target != expected_target:
+            if current_target == expected_target and expected_session_id is None:
+                expected_session_id = tmux_server.target_session_id(
+                    expected_target, "railmux", timeout=0.5)
+
+            from railmux.provider_paths import running_in_managed_windows_wrapper
+
+            managed_windows = running_in_managed_windows_wrapper()
+
+            can_relay = bool(
+                current_target == expected_target
+                and expected_session_id is not None
+                and failed_at - started_at < 5.0
+                and attributes is not None
+                and sys.stdout.isatty()
+                and managed_windows
+            )
+            if can_relay:
+                relay_attempted = True
+                from railmux.windows_attach_relay import (
+                    WindowsAttachRelayError,
+                    start_relay_client,
+                )
+
+                print(
+                    "info: direct tmux attach was unavailable; reconnecting "
+                    "through the Windows terminal bridge",
+                    file=sys.stderr,
+                )
+                try:
+                    tty.setraw(sys.stdin.fileno())
+                    relay = start_relay_client(
+                        target=expected_target,
+                        session_id=expected_session_id,
+                        environ=env,
+                        stdin_fd=sys.stdin.fileno(),
+                        stdout_fd=sys.stdout.fileno(),
+                    )
+                    process = relay
+                    returncode, watchdog_failed = monitor_client(
+                        asynchronous_probe=True)
+                    if returncode:
+                        _reset_terminal_modes(sys.stdout.fileno())
+                    if watchdog_failed:
+                        return returncode
+                except (OSError, termios.error, WindowsAttachRelayError):
+                    _reset_terminal_modes(sys.stdout.fileno())
+                    _restore_terminal(attributes)
+                    outcome = (
+                        "could not attach"
+                        if relay is None
+                        else "connection ended unexpectedly"
+                    )
+                    print(
+                        f"error: the Windows terminal bridge {outcome}; the "
+                        "existing workspace was left running; run "
+                        "'railmux doctor' for diagnostics",
+                        file=sys.stderr,
+                    )
+                    returncode = 2
+                finally:
+                    _restore_terminal(attributes)
+
+                if returncode:
+                    try:
+                        current_target = tmux_server.discover_target(timeout=1.0)
+                    except tmux_server.TmuxServerError:
+                        current_target = None
+
+            if returncode and current_target != expected_target:
                 clean_exit = bool(
                     expected_session_id is not None
                     and tmux_health.consume_clean_exit(
@@ -156,16 +282,41 @@ def _run_tmux_client_with_watchdog(
                         reason="launcher-server-exit",
                         consecutive_failures=1,
                     )
+            elif (
+                returncode
+                and current_target == expected_target
+                and managed_windows
+            ):
+                tmux_health.record_incident(
+                    component="launcher",
+                    reason=(
+                        "launcher-relay-failed"
+                        if relay_attempted
+                        else "launcher-attach-rejected"
+                    ),
+                    consecutive_failures=1,
+                )
+        # Routine post-exit removal of a proof-authorized last-session socket
+        # is housekeeping. Only pre-launch recovery is user-visible.
+        windows_tmux_lifecycle.recover_abandoned_socket()
         return returncode
     except KeyboardInterrupt:
         _stop_tmux_client(process)
+        if relay is not None:
+            _reset_terminal_modes(sys.stdout.fileno())
         return 130
     finally:
+        if relay is not None:
+            relay.close()
         _restore_terminal(attributes)
 
 
 def main(argv: list[str] | None = None) -> int:
     raw_args = list(sys.argv[1:] if argv is None else argv)
+    if raw_args and raw_args[0] == "_windows-attach-relay":
+        from railmux.windows_attach_relay import relay_server_main
+
+        return relay_server_main(raw_args[1:])
     if raw_args and raw_args[0] == "config":
         from railmux.config_cli import main as config_main
 
@@ -379,8 +530,9 @@ def main(argv: list[str] | None = None) -> int:
         tmux_server.socket_label()
         if windows_tmux_lifecycle.recover_abandoned_socket():
             print(
-                "info: cleaned an abandoned Windows tmux socket; Codex and "
-                "Claude session files were not changed",
+                "info: recovered an unresponsive Windows tmux socket left by "
+                "a previous session; Codex and Claude session files were not "
+                "changed",
                 file=sys.stderr,
             )
         dedicated_target = tmux_server.discover_target()

{railmux-0.4.0.dev14 → railmux-0.4.0.dev16}/src/railmux/diagnostics.py

@@ -426,6 +426,8 @@ def _incident_text(diagnostic: IncidentDiagnostic) -> str:
     if diagnostic.status == "none":
         return "none recorded"
     descriptions = {
+        "launcher-attach-rejected": "Windows tmux client attach rejected",
+        "launcher-relay-failed": "Windows terminal bridge failed",
         "launcher-watchdog-timeout": "local client watchdog timeout",
         "launcher-server-exit": "dedicated tmux server exited",
         "remote-display-watchdog-timeout": "SSH display watchdog timeout",