luv-cli 0.5.0__tar.gz → 0.5.1__tar.gz

luv_cli-0.5.1/.failproofai/policies/version-policies.mjs

@@ -0,0 +1,107 @@
+/**
+ * version-policies.mjs — remind the agent to bump the release version.
+ *
+ * Auto-loaded by failproofai from .failproofai/policies/ — no install step.
+ *
+ * Publishing here is driven by the version in the manifest: a push to main
+ * whose version has no tag yet releases itself (.github/workflows/publish.yml).
+ * So a branch that changes the tool and forgets the version merges into a main
+ * that publishes nothing, and the change sits unreleased until someone notices.
+ *
+ * So this says so on `git commit`, and only while the branch's version still
+ * matches the base branch's — it is context, not a block, and bumping the
+ * version is what turns it off for the rest of the branch.
+ */
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { customPolicies, allow, instruct } from "failproofai";
+
+// First match wins, so the order is "most likely to be the release manifest".
+const MANIFESTS = [
+  { file: "pyproject.toml", re: /^\s*version\s*=\s*["']([^"']+)["']/m },
+  { file: "package.json", re: /"version"\s*:\s*"([^"]+)"/ },
+  { file: "Cargo.toml", re: /^\s*version\s*=\s*["']([^"']+)["']/m },
+];
+
+const BASE_REFS = ["origin/main", "main", "origin/master", "master"];
+
+// A `git … commit` that starts a command, so a shell segment is allowed to
+// carry flags and their values (`git -C dir commit`) but a `commit` merely
+// spoken about (`echo "run git commit later"`) is not mistaken for one.
+const GIT_COMMIT = /(?:^|[;&|\n(]|&&|\|\|)\s*(?:\w+=\S+\s+)*git\b[^;&|\n]*?\bcommit\b/;
+
+/** git, or null on any failure — this policy never gets in the way. */
+function git(cwd, args) {
+  try {
+    return execFileSync("git", args, {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 5000,
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function versionIn(text, re) {
+  const m = text == null ? null : text.match(re);
+  return m ? m[1] : null;
+}
+
+/** The manifest this repo releases from, with the version on both sides. */
+function releaseVersions(cwd) {
+  const base = BASE_REFS.find((ref) =>
+    git(cwd, ["rev-parse", "--verify", "--quiet", ref]) !== null);
+  if (!base) return null;
+
+  for (const { file, re } of MANIFESTS) {
+    if (!existsSync(join(cwd, file))) continue;
+    let head;
+    try {
+      head = versionIn(readFileSync(join(cwd, file), "utf8"), re);
+    } catch {
+      return null;
+    }
+    // No version on the base side means the manifest is new on this branch;
+    // there is nothing to bump relative to.
+    const baseVersion = versionIn(git(cwd, ["show", `${base}:${file}`]), re);
+    if (!head || !baseVersion) return null;
+    return { file, base, head, baseVersion };
+  }
+  return null;
+}
+
+customPolicies.add({
+  name: "remind-version-bump-on-commit",
+  description: "On git commit, remind that the release version is still the base branch's",
+  match: { events: ["PreToolUse"] },
+  fn: async (ctx) => {
+    if (ctx.toolName !== "Bash") return allow();
+    const cmd = String(ctx.toolInput?.command ?? "");
+    if (!GIT_COMMIT.test(cmd)) return allow();
+
+    const cwd = ctx.session?.cwd ?? process.cwd();
+
+    // Committing on the base branch is a different problem, and one the
+    // block-work-on-main policy already has an opinion about.
+    const branch = git(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
+    if (branch === null || branch === "main" || branch === "master") return allow();
+
+    const found = releaseVersions(cwd);
+    if (!found) return allow();
+    if (found.head !== found.baseVersion) return allow(); // already bumped
+
+    return instruct(
+      `${found.file} still says version ${found.head}, the same as ${found.base}. ` +
+      "Releases are cut from that version when this branch lands, so a merge " +
+      "with it unchanged publishes nothing. Bump it in this branch — patch for " +
+      "a fix or polish, minor for a feature — unless the change is docs, tests, " +
+      "or CI only, in which case say so and carry on."
+    );
+  },
+});
+
+export { customPolicies };

luv_cli-0.5.1/.github/workflows/publish.yml

@@ -0,0 +1,117 @@
+name: Publish to PyPI
+
+# Two ways in.
+#
+#   * A push to main publishes when the version in pyproject.toml is one no tag
+#     exists for yet. That is what makes a merged version bump release itself.
+#   * A v* tag publishes whatever it points at, kept so a release can still be
+#     cut by hand.
+#
+# The tag is created here rather than by a separate workflow because a tag
+# pushed with GITHUB_TOKEN does not trigger other workflows — GitHub's recursion
+# guard. Tagging elsewhere and relying on the v* trigger to fire would leave the
+# tag in place and nothing published, which is the worst of both.
+#
+# Deliberately no `paths:` filter. It would be evaluated for tag pushes as well,
+# so `paths: [pyproject.toml]` would silently drop a hand-pushed tag whose commit
+# did not happen to touch that file. The "is this already tagged" check below is
+# the real guard; a filter would only be an optimisation, and a lossy one.
+
+on:
+  push:
+    tags:
+      - "v*"
+    branches:
+      - main
+
+concurrency:
+  group: publish
+  cancel-in-progress: false
+
+jobs:
+  decide:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    outputs:
+      publish: ${{ steps.resolve.outputs.publish }}
+      version: ${{ steps.resolve.outputs.version }}
+      needs_tag: ${{ steps.resolve.outputs.needs_tag }}
+    steps:
+      # Its own job so the pypi environment — which may require a reviewer — is
+      # never entered by a run that turns out to have nothing to publish.
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0 # tags, so the guard below can see them
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Work out whether there is a release to make
+        id: resolve
+        run: |
+          set -euo pipefail
+
+          if [ "${GITHUB_REF_TYPE}" = "tag" ]; then
+            version="${GITHUB_REF_NAME#v}"
+            needs_tag=false
+          else
+            version="$(python -c 'import tomllib; print(tomllib.load(open("pyproject.toml","rb"))["project"]["version"])')"
+            needs_tag=true
+          fi
+
+          if [ -z "${version}" ]; then
+            echo "could not determine a version to publish" >&2
+            exit 1
+          fi
+
+          if [ "${needs_tag}" = true ] && git rev-parse -q --verify "refs/tags/v${version}" >/dev/null; then
+            echo "v${version} is already tagged — nothing to release"
+            echo "publish=false" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+
+          echo "releasing ${version}"
+          echo "version=${version}" >> "$GITHUB_OUTPUT"
+          echo "needs_tag=${needs_tag}" >> "$GITHUB_OUTPUT"
+          echo "publish=true" >> "$GITHUB_OUTPUT"
+
+  publish:
+    needs: decide
+    if: needs.decide.outputs.publish == 'true'
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      contents: write # push the tag a merged version bump implies
+      id-token: write # PyPI trusted publishing
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      # Before the build, so a tag that cannot be pushed — protected tags, say —
+      # fails the run rather than publishing a version with no tag to show for it.
+      - name: Tag the release
+        if: needs.decide.outputs.needs_tag == 'true'
+        env:
+          VERSION: ${{ needs.decide.outputs.version }}
+        run: |
+          set -euo pipefail
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git tag -a "v${VERSION}" -m "v${VERSION}"
+          git push origin "v${VERSION}"
+
+      - name: Install build tools
+        run: pip install build
+
+      - name: Build package
+        run: python -m build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

{luv_cli-0.5.0 → luv_cli-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: luv-cli
-Version: 0.5.0
+Version: 0.5.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.5.0 → luv_cli-0.5.1}/docs/remote-sessions.md

@@ -256,6 +256,19 @@ luv -i ~/.ssh/other_key myrepo      # use a different key this once
 Detach from a session with `Ctrl-b d` (tmux's default prefix). The agent keeps
 running.
 
+When a session ends on its own — the connection drops, ssh is killed, the pane
+dies — luv prints the way back in, already filled in for that session:
+
+```
+luv: session ended unexpectedly — continue it with:
+
+    luv continue myrepo 42
+```
+
+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.
+
 ## Reaching servers the agent started
 
 An agent working on the remote starts servers there — a dev server, a compose
@@ -409,7 +422,7 @@ machine with `--from` and luv will move the folder and start it fresh.
 | Step | What happens |
 |---|---|
 | `luv myrepo "…"` | Laptop records a registry entry, opens SSH, creates the tmux session, remote luv clones and launches the agent |
-| `Ctrl-b d` or lost connection | tmux session keeps running; agent unaffected; Docker containers stay up |
+| `Ctrl-b d` or lost connection | tmux session keeps running; agent unaffected; Docker containers stay up. A connection that broke leaves the exact `luv continue <repo> <n>` for it in your terminal |
 | `luv ls` | Laptop queries every known host's tmux and refreshes the registry, adopting sessions another machine started |
 | `luv continue` | Reattaches; other clients are detached so the pane isn't size-clamped |
 | Agent exits | The pane's command ends, tmux session disappears, Docker environment is torn down, `luv ls` prunes the entry on its next run |

{luv_cli-0.5.0 → luv_cli-0.5.1}/luv/__init__.py

@@ -1585,7 +1585,36 @@ def terminal_guard():
                 os.write(fd, TERM_RESET.encode())
 
 
-def hand_over(argv: list[str], *, restore: bool = True, watch=None) -> None:
+def continue_hint(repo: str | None, workspace: str | None = None) -> str:
+    """The 'luv continue …' line to hand back when a session breaks.
+
+    As narrow as what we actually know, and no narrower: the number is read off
+    the workspace folder, which a session dispatched before the remote picked
+    one doesn't have yet. Every shorter form is still a command that works —
+    a repo alone takes its newest session, and bare 'luv continue' asks.
+    """
+    parts = ["luv", "continue"]
+    if repo:
+        parts.append(repo)
+        number = workspace_number(repo, workspace or "")
+        if number is not None:
+            parts.append(str(number))
+    return " ".join(parts)
+
+
+def reopen_hint(args: list[str]) -> str:
+    """The 'luv <repo> [n] -r' line for a session whose tmux is already gone.
+
+    Takes the same [<repo> [number]] grammar 'luv continue' does, so whatever
+    was just typed carries straight over to the command that still works.
+    """
+    repo = args[0].rstrip("/").rsplit("/", 1)[-1]
+    number = args[1] if len(args) > 1 and args[1].isdigit() else None
+    return " ".join(["luv", repo] + ([number] if number else []) + ["-r"])
+
+
+def hand_over(argv: list[str], *, restore: bool = True, watch=None,
+              hint: 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
@@ -1604,6 +1633,12 @@ def hand_over(argv: list[str], *, restore: bool = True, watch=None) -> None:
     the agent starts ten minutes in. It runs on a daemon thread and touches
     neither the terminal nor termios — this path is the one that has to stay
     boring.
+
+    `hint` is the way back in, printed when the child exits badly. A clean exit
+    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.
     """
     if not restore:
         os.execv(argv[0], argv)
@@ -1620,19 +1655,25 @@ def hand_over(argv: list[str], *, restore: bool = True, watch=None) -> None:
                     # The child got this same Ctrl-C from the tty and decides
                     # for itself what to do with it; outliving it is the point.
                     continue
+        if code != 0 and 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)
         sys.exit(code)
 
 
-def exec_ssh(hc: dict, remote_cmd: str, *, tty: bool = True, watch=None) -> None:
+def exec_ssh(hc: dict, remote_cmd: str, *, tty: bool = True, watch=None,
+             hint: str | None = None) -> None:
     """Hand the terminal to ssh. Never returns."""
     ssh_bin = shutil.which("ssh")
     if not ssh_bin:
         die("'ssh' not found in PATH")
     argv = ssh_base(hc, tty=tty) + [remote_shell(remote_cmd)]
-    hand_over([ssh_bin] + argv[1:], restore=tty, watch=watch)
+    hand_over([ssh_bin] + argv[1:], restore=tty, watch=watch, hint=hint)
 
 
-def attach_session(hc: dict | None, name: str) -> None:
+def attach_session(hc: dict | None, name: str, *, hint: 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
@@ -1642,11 +1683,11 @@ def attach_session(hc: dict | None, name: str) -> None:
         tmux_bin = shutil.which("tmux")
         if not tmux_bin:
             die("'tmux' not found in PATH")
-        hand_over([tmux_bin, "attach", "-d", "-t", name])
+        hand_over([tmux_bin, "attach", "-d", "-t", name], hint=hint)
         return
     print(f"luv: attaching {name} on {hc['host']}")
     exec_ssh(hc, shlex.join(["tmux", "attach", "-d", "-t", name]),
-             watch=port_watch(hc, session=name))
+             watch=port_watch(hc, session=name), hint=hint)
 
 
 def remote_prompt(args: list[str]) -> str | None:
@@ -1758,14 +1799,18 @@ def dispatch_remote(hc: dict, remote_args: list[str], *, workspace: str | None =
         record_session({**meta, "id": sid, "host": hc["host"], "session": session,
                         "workspace": workspace, "created": int(time.time())})
 
+    # 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
     print(f"luv: {hc['host']} — {session or 'no tmux'}")
     if detach:
         r = run(ssh_base(hc, batch=True) + [remote_shell(cmd)])
         if r.returncode != 0:
             die(f"could not start {session} on {hc['host']}: {r.stderr.strip()}")
-        print(f"luv: started detached — 'luv continue' to attach")
+        print(f"luv: started detached — attach with: {hint or 'luv continue'}")
         return
-    exec_ssh(hc, cmd, tty=tty, watch=port_watch(hc, sid=sid, session=session))
+    exec_ssh(hc, cmd, tty=tty, watch=port_watch(hc, sid=sid, session=session),
+             hint=hint)
 
 
 def cmd_paths() -> None:
@@ -3145,14 +3190,21 @@ def cmd_continue(args: list[str], identity: str | None = None) -> None:
     live, label = filter_sessions([s for s in sessions if s.get("live")], args)
 
     if not live:
-        die(f"no live luv sessions{label}")
+        # This is where a hint printed after a crash lands when the agent took
+        # the tmux session down with it, so send it on rather than stopping at
+        # the bad news: the workspace outlives the session, and -r reopens it.
+        named = bool(args) and not args[0].startswith("-")
+        die(f"no live luv sessions{label}"
+            + (f" — if its workspace is still there: {reopen_hint(args)}"
+               if named else ""))
     live.sort(key=session_sort_key, reverse=True)
 
     # An explicit repo means "the newest one for it".
     target = live[0] if (len(live) == 1 or args) else choose_session(live)
 
     host = target.get("host")
-    attach_session(resolve_host(host, identity) if host else None, target["session"])
+    attach_session(resolve_host(host, identity) if host else None, target["session"],
+                   hint=continue_hint(target.get("repo"), target.get("workspace")))
 
 
 def start_local_session(workspace: str, luv_args: list[str], meta: dict,
@@ -3170,13 +3222,14 @@ def start_local_session(workspace: str, luv_args: list[str], meta: dict,
              shutil.which("luv") or "luv"] + luv_args
     argv = [tmux_bin, "new-session"] + ([] if attach else ["-d"]) + \
            ["-A", "-s", session, "--"] + inner
+    hint = continue_hint(meta.get("repo"), workspace)
     print(f"luv: local — {session}")
     if attach:
-        os.execv(tmux_bin, argv)
+        hand_over(argv, hint=hint)
     r = subprocess.run(argv)
     if r.returncode != 0:
         die(f"could not start {session}")
-    print("luv: started detached — 'luv continue' to attach")
+    print(f"luv: started detached — attach with: {hint}")
 
 
 def workspace_origin(hc: dict | None, ws: Path) -> tuple[str, str] | None:
@@ -3471,7 +3524,8 @@ Remote:
   Once 'luv config' has a remote host, every workspace command runs there inside
   a tmux session that survives disconnects. 'luv ls' shows what is running on
   every host — including sessions started from another machine — and
-  'luv continue' reattaches. Use --local for a one-off local run.
+  'luv continue' reattaches. A session that ends badly prints the exact
+  'luv continue <repo> <n>' for itself. Use --local for a one-off local run.
   'luv handover' moves a running session — workspace, uncommitted work, and the
   agent's conversation — to another machine, then resumes it there.
   Requires luv, tmux, gh and git on the remote. See docs/remote-sessions.md.

{luv_cli-0.5.0 → luv_cli-0.5.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "luv-cli"
-version = "0.5.0"
+version = "0.5.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.5.0 → luv_cli-0.5.1}/tests/test_agents.py

@@ -387,6 +387,142 @@ class TerminalRestoreTests(unittest.TestCase):
         self.assertNotEqual(hand_over.call_args.kwargs.get("restore"), False)
 
 
+class _OrderedStderr(io.StringIO):
+    """A stderr that notes where its first write falls in a sequence."""
+
+    def __init__(self, order):
+        super().__init__()
+        self.order = order
+
+    def write(self, s):
+        if s.strip() and "hint" not in self.order:
+            self.order.append("hint")
+        return super().write(s)
+
+
+class ContinueHintTests(unittest.TestCase):
+    """A session that breaks must say how to get back into it, in one line
+    that can be copied off the terminal and run as-is."""
+
+    FD = TerminalRestoreTests.FD
+    SAVED = TerminalRestoreTests.SAVED
+    HINT = "luv continue myrepo 42"
+
+    def _hand_over(self, stderr, **kwargs):
+        """Run hand_over over a fake child, with the terminal all stubbed out."""
+        with (patch.object(luv, "terminal_fd", return_value=self.FD),
+              patch.object(luv.subprocess, "Popen",
+                           return_value=_FakeProc(kwargs.pop("returncode", 0))),
+              patch.object(luv.termios, "tcgetattr", return_value=self.SAVED),
+              patch.object(luv.termios, "tcsetattr"),
+              patch.object(luv.os, "write", side_effect=self.on_write),
+              contextlib.redirect_stderr(stderr),
+              self.assertRaises(SystemExit) as exit_ctx):
+            luv.hand_over(["/bin/ssh", "box"], **kwargs)
+        return exit_ctx.exception.code
+
+    def on_write(self, fd, data):
+        return len(data)
+
+    def test_broken_session_hands_back_a_runnable_command(self):
+        err = io.StringIO()
+        code = self._hand_over(err, returncode=255, hint=self.HINT)
+
+        self.assertEqual(code, 255)
+        self.assertIn(self.HINT, err.getvalue())
+        # Copy-pasteable means the whole command sits on a line of its own, with
+        # nothing but indentation around it to select past.
+        line = next(l for l in err.getvalue().splitlines() if self.HINT in l)
+        self.assertEqual(line.strip(), self.HINT)
+
+    def test_a_clean_exit_says_nothing(self):
+        # Detaching and the agent finishing both land here; neither is broken.
+        err = io.StringIO()
+        code = self._hand_over(err, returncode=0, hint=self.HINT)
+
+        self.assertEqual(code, 0)
+        self.assertNotIn("luv continue", err.getvalue())
+
+    def test_the_hint_waits_for_the_terminal_to_be_restored(self):
+        # Printed inside the guard it would land in the remote program's modes,
+        # which is where unreadable output comes from in the first place.
+        order = []
+        self.on_write = lambda fd, data: order.append("reset")
+        self._hand_over(_OrderedStderr(order), returncode=255, hint=self.HINT)
+
+        self.assertEqual(order, ["reset", "hint"])
+
+    def test_hint_names_the_repo_and_number_it_knows(self):
+        self.assertEqual(luv.continue_hint("myrepo", "myrepo-box-42"),
+                         "luv continue myrepo 42")
+        self.assertEqual(luv.continue_hint("myrepo", "myrepo-42"),
+                         "luv continue myrepo 42", "pre-slug folders too")
+
+    def test_hint_degrades_to_what_is_known(self):
+        # A brand-new workspace has no number until the remote picks one, and an
+        # adopted session may not even have a repo. Both shorter forms still run.
+        self.assertEqual(luv.continue_hint("myrepo", "luv-pending-abc123"),
+                         "luv continue myrepo")
+        self.assertEqual(luv.continue_hint("myrepo", None), "luv continue myrepo")
+        self.assertEqual(luv.continue_hint(None, "myrepo-box-42"), "luv continue")
+
+    def test_remote_session_carries_its_own_hint(self):
+        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, "hand_over") as hand_over,
+              contextlib.redirect_stdout(io.StringIO())):
+            luv.dispatch_remote({"host": "box"}, ["myrepo", "42"],
+                                workspace="myrepo-box-42",
+                                meta={"repo": "myrepo", "org": "acme"})
+
+        self.assertEqual(hand_over.call_args.kwargs.get("hint"),
+                         "luv continue myrepo 42")
+
+    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}"),
+              patch.object(luv, "port_watch", return_value=None),
+              patch.object(luv, "hand_over") as hand_over,
+              contextlib.redirect_stdout(io.StringIO())):
+            luv.dispatch_remote({"host": "box"}, ["myrepo", "42", "-nit"],
+                                use_tmux=False, tty=False)
+
+        self.assertIsNone(hand_over.call_args.kwargs.get("hint"))
+
+    def test_attaching_carries_the_hint_for_the_session_it_picked(self):
+        row = {"host": "box", "session": "luv-myrepo-42", "live": True,
+               "repo": "myrepo", "workspace": "myrepo-box-42"}
+        with (patch.object(luv, "refresh_sessions", return_value=([row], set())),
+              patch.object(luv, "resolve_host", return_value={"host": "box"}),
+              patch.object(luv, "attach_session") as attach,
+              contextlib.redirect_stdout(io.StringIO())):
+            luv.cmd_continue(["myrepo", "42"])
+
+        self.assertEqual(attach.call_args.kwargs.get("hint"),
+                         "luv continue myrepo 42")
+
+    def test_a_session_that_is_already_gone_points_at_the_reopen(self):
+        # Where the hint lands when the agent took the tmux session down with
+        # it: the workspace outlives the session, so pass the user on.
+        with (patch.object(luv, "refresh_sessions", return_value=([], set())),
+              contextlib.redirect_stdout(io.StringIO())):
+            with self.assertRaises(SystemExit):
+                with contextlib.redirect_stderr(io.StringIO()) as err:
+                    luv.cmd_continue(["myrepo", "42"])
+
+        self.assertIn("luv myrepo 42 -r", err.getvalue())
+
+    def test_nothing_live_at_all_suggests_nothing(self):
+        with (patch.object(luv, "refresh_sessions", return_value=([], set())),
+              contextlib.redirect_stdout(io.StringIO())):
+            with self.assertRaises(SystemExit):
+                with contextlib.redirect_stderr(io.StringIO()) as err:
+                    luv.cmd_continue([])
+
+        self.assertNotIn("-r", err.getvalue())
+
+
 class SessionNameTests(unittest.TestCase):
     def test_illegal_tmux_characters_are_replaced(self):
         self.assertEqual(luv.tmux_session_name("foo.js-7"), "luv-foo_js-7")

luv_cli-0.5.0/.github/workflows/publish.yml

@@ -1,29 +0,0 @@
-name: Publish to PyPI
-
-on:
-  push:
-    tags:
-      - "v*"
-
-permissions:
-  id-token: write
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    environment: pypi
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-python@v5
-        with:
-          python-version: "3.12"
-
-      - name: Install build tools
-        run: pip install build
-
-      - name: Build package
-        run: python -m build
-
-      - name: Publish to PyPI
-        uses: pypa/gh-action-pypi-publish@release/v1