luv-cli 0.6.0__tar.gz → 0.6.1__tar.gz

{luv_cli-0.6.0 → luv_cli-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: luv-cli
-Version: 0.6.0
+Version: 0.6.1
 Summary: Launch Claude Code or Codex agents on GitHub repos with isolated workspaces and optional Docker dev environments
 Project-URL: Homepage, https://github.com/exospherehost/luv
 Project-URL: Repository, https://github.com/exospherehost/luv

{luv_cli-0.6.0 → luv_cli-0.6.1}/docs/remote-sessions.md

@@ -265,6 +265,12 @@ luv: session ended unexpectedly — continue it with:
     luv continue myrepo 42
 ```
 
+The number is there even when you never typed one: `luv myrepo "…"` doesn't
+know which workspace it will get — the remote reads that off `gh api` — so the
+line is worked out at the point it is printed, by asking the session which
+folder it ended up in. Without it the hint would name the repo alone, and that
+attaches to whichever of its sessions is newest, which may not be this one.
+
 Copy that line and run it. If the agent took the tmux session down with it,
 there is nothing left to attach to; `luv continue` says so and hands you
 `luv myrepo 42 -r`, which reopens the workspace and resumes the conversation.

{luv_cli-0.6.0 → luv_cli-0.6.1}/luv/__init__.py

@@ -13,6 +13,7 @@ import sys
 import tempfile
 import threading
 import time
+from collections.abc import Callable
 from pathlib import Path
 
 try:
@@ -1680,6 +1681,19 @@ def continue_hint(repo: str | None, workspace: str | None = None) -> str:
     return " ".join(parts)
 
 
+def dispatched_workspace(hc: dict, sid: str) -> str | None:
+    """The workspace a dispatched session landed in, asked of the host.
+
+    Dispatch only knows the folder name when the number was on the command
+    line; otherwise the remote reads it off gh api and stamps it onto its own
+    tmux session, and asking is the only way back to it from here.
+    """
+    for row in query_tmux(hc) or []:
+        if row["id"] == sid:
+            return row["workspace"] or None
+    return None
+
+
 def reopen_hint(args: list[str]) -> str:
     """The 'luv <repo> [n] -r' line for a session whose tmux is already gone.
 
@@ -1692,7 +1706,7 @@ def reopen_hint(args: list[str]) -> str:
 
 
 def hand_over(argv: list[str], *, restore: bool = True, watch=None,
-              hint: str | None = None) -> None:
+              hint: str | Callable[[], str] | None = None) -> None:
     """Give the terminal to a child and exit with its status. Never returns.
 
     Without `restore` this is a plain execv, which is the better deal when
@@ -1716,7 +1730,9 @@ def hand_over(argv: list[str], *, restore: bool = True, watch=None,
     is either a detach or the agent finishing, and neither wants advice; a bad
     one is usually ssh losing the connection out from under a session that is
     still running on the other side, and the terminal it lands back in should
-    not have to be told twice how to get there.
+    not have to be told twice how to get there. It may be a callable, for the
+    hint that cannot be written until the session it describes has run: only
+    the bad exit pays for working it out, and only once.
     """
     if not restore:
         os.execv(argv[0], argv)
@@ -1734,15 +1750,16 @@ def hand_over(argv: list[str], *, restore: bool = True, watch=None,
                     # for itself what to do with it; outliving it is the point.
                     continue
         if code != 0 and hint:
+            line = hint() if callable(hint) else hint
             # After the guard, not inside it: a terminal still in the remote
             # program's modes is no place to print something to be copied.
             print(f"\nluv: session ended unexpectedly — continue it with:\n\n"
-                  f"    {hint}\n", file=sys.stderr)
+                  f"    {line}\n", file=sys.stderr)
         sys.exit(code)
 
 
 def exec_ssh(hc: dict, remote_cmd: str, *, tty: bool = True, watch=None,
-             hint: str | None = None) -> None:
+             hint: str | Callable[[], str] | None = None) -> None:
     """Hand the terminal to ssh. Never returns."""
     ssh_bin = shutil.which("ssh")
     if not ssh_bin:
@@ -1751,7 +1768,8 @@ def exec_ssh(hc: dict, remote_cmd: str, *, tty: bool = True, watch=None,
     hand_over([ssh_bin] + argv[1:], restore=tty, watch=watch, hint=hint)
 
 
-def attach_session(hc: dict | None, name: str, *, hint: str | None = None) -> None:
+def attach_session(hc: dict | None, name: str, *,
+                   hint: str | Callable[[], str] | None = None) -> None:
     """Attach to a tmux session, locally or over ssh. Never returns.
 
     -d detaches other clients so the pane isn't size-clamped to a stale window
@@ -1879,7 +1897,8 @@ def dispatch_remote(hc: dict, remote_args: list[str], *, workspace: str | None =
 
     # Only a tmux session is there to come back to; -nit and --clean run to
     # completion over ssh and have nothing to continue.
-    hint = continue_hint((meta or {}).get("repo"), workspace) if use_tmux else None
+    repo = (meta or {}).get("repo")
+    hint = continue_hint(repo, workspace) if use_tmux else None
     print(f"luv: {hc['host']} — {session or 'no tmux'}")
     if detach:
         r = run(ssh_base(hc, batch=True) + [remote_shell(cmd)])
@@ -1887,6 +1906,16 @@ def dispatch_remote(hc: dict, remote_args: list[str], *, workspace: str | None =
             die(f"could not start {session} on {hc['host']}: {r.stderr.strip()}")
         print(f"luv: started detached — attach with: {hint or 'luv continue'}")
         return
+    def late_hint() -> str:
+        """The same hint, worked out after the session rather than before it."""
+        return continue_hint(repo, dispatched_workspace(hc, sid))
+
+    # A dispatch without a number is the ordinary case, and the repo on its own
+    # points at whichever of its sessions is newest — which by then may not be
+    # this one. Deferring costs a round trip only when a session breaks, and by
+    # then the remote has long since picked its number and stamped it on tmux.
+    if use_tmux and repo and not workspace:
+        hint = late_hint
     exec_ssh(hc, cmd, tty=tty, watch=port_watch(hc, sid=sid, session=session),
              hint=hint)
 

{luv_cli-0.6.0 → luv_cli-0.6.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "luv-cli"
-version = "0.6.0"
+version = "0.6.1"
 description = "Launch Claude Code or Codex agents on GitHub repos with isolated workspaces and optional Docker dev environments"
 requires-python = ">=3.10"
 license = "MIT"

{luv_cli-0.6.0 → luv_cli-0.6.1}/tests/test_agents.py

@@ -479,6 +479,54 @@ class ContinueHintTests(unittest.TestCase):
         self.assertEqual(hand_over.call_args.kwargs.get("hint"),
                          "luv continue myrepo 42")
 
+    def _dispatch_hint(self, tmux_rows, **kwargs):
+        """The hint a numberless dispatch hands back, against a host that
+        answers with `tmux_rows`."""
+        with (patch.object(luv.shutil, "which", side_effect=lambda n: f"/bin/{n}"),
+              patch.object(luv, "record_session"),
+              patch.object(luv, "port_watch", return_value=None),
+              patch.object(luv, "query_tmux", return_value=tmux_rows) as query,
+              patch.object(luv, "hand_over") as hand_over,
+              contextlib.redirect_stdout(io.StringIO())):
+            luv.dispatch_remote({"host": "box"}, ["myrepo"],
+                                meta={"repo": "myrepo", "org": "acme"}, **kwargs)
+            hint = hand_over.call_args.kwargs.get("hint")
+            # Nothing is asked of the host until the hint is actually needed.
+            self.assertFalse(query.called)
+            return hint() if callable(hint) else hint
+
+    def test_a_session_dispatched_without_a_number_finds_its_own(self):
+        # The number comes off gh api on the remote, so the only way to name it
+        # is to ask the session that picked it — once, and only if it breaks.
+        rows = [{"id": "other123", "session": "luv-myrepo-box-7",
+                 "workspace": "myrepo-box-7", "attached": False, "activity": 0}]
+        with patch.object(luv, "new_session_id", return_value="abc12345"):
+            rows.append({"id": "abc12345", "session": "luv-myrepo-box-42",
+                         "workspace": "myrepo-box-42", "attached": True,
+                         "activity": 0})
+            hint = self._dispatch_hint(rows)
+
+        self.assertEqual(hint, "luv continue myrepo 42")
+
+    def test_an_unreachable_host_still_hands_back_a_runnable_line(self):
+        # query_tmux returns None when the host never answered — which is the
+        # usual reason a session broke in the first place.
+        self.assertEqual(self._dispatch_hint(None), "luv continue myrepo")
+
+    def test_a_detached_start_does_not_wait_on_a_number(self):
+        # Nothing has been cloned yet, so there is no number to find; the line
+        # printed here has to be one, not a deferred callable.
+        with (patch.object(luv, "run", return_value=_FakeProc(0)),
+              patch.object(luv.shutil, "which", side_effect=lambda n: f"/bin/{n}"),
+              patch.object(luv, "record_session"),
+              patch.object(luv, "query_tmux") as query,
+              contextlib.redirect_stdout(io.StringIO()) as out):
+            luv.dispatch_remote({"host": "box"}, ["myrepo"], detach=True,
+                                meta={"repo": "myrepo", "org": "acme"})
+
+        self.assertFalse(query.called)
+        self.assertIn("attach with: luv continue myrepo", out.getvalue())
+
     def test_a_run_with_no_session_behind_it_gets_no_hint(self):
         # -nit streams to a pipe and exits; there is nothing to continue.
         with (patch.object(luv.shutil, "which", side_effect=lambda n: f"/bin/{n}"),