alissa-tools-github-devloop 0.8.51__py3-none-any.whl → 0.8.53__py3-none-any.whl

alissa/tools/github/devloop/hungtests.py

@@ -125,16 +125,23 @@ class TestTree:
     @property
     def session(self) -> "str | None":
         """The owning session's roster name (no `ali-` prefix), or None."""
-        name = self.tmux_session
-        if not name:
-            return None
-        return name[len(TMUX_PREFIX):] if name.startswith(TMUX_PREFIX) else name
+        return roster_name(self.tmux_session)
 
     @property
     def command(self) -> str:
         return " ".join(self.root.argv)
 
 
+def roster_name(tmux_session: "str | None") -> "str | None":
+    """A seat env's `ALISSA_TMUX_SESSION` as the roster's name (no `ali-`
+    prefix), or None when the env names no session."""
+    if not tmux_session:
+        return None
+    if tmux_session.startswith(TMUX_PREFIX):
+        return tmux_session[len(TMUX_PREFIX):] or None
+    return tmux_session
+
+
 def _clock_ticks() -> int:
     try:
         return int(os.sysconf("SC_CLK_TCK")) or 100
@@ -424,6 +431,19 @@ def kill_tree(
     if current is None or current.start != tree.root.start:
         return 0, 0
     members = [m for m in descendants(fresh, tree.root.pid) if m.alive]
+    return kill_procs(members, root=root, grace=grace)
+
+
+def kill_procs(
+    members: "Sequence[Proc]",
+    *,
+    root: "Path | None" = None,
+    grace: float = KILL_GRACE_SECONDS,
+) -> "tuple[int, int]":
+    """TERM every member still alive under its recorded start time, wait up
+    to `grace` seconds, then KILL the survivors. Returns (termed, killed).
+    A member whose pid now belongs to another process is never signalled."""
+    members = [m for m in members if _still_alive(m, root)]
     for member in members:
         send_signal(member.pid, signal.SIGTERM)
     deadline = monotonic() + grace
@@ -479,3 +499,147 @@ def hung_message(tree: TestTree, minutes: int, reason: str) -> str:
         f"touches, each on its own, one file per command. CI on the PR runs "
         f"the full suite."
     )
+
+
+# -- the dead-session process reaper (issue #186) -----------------------------
+#
+# 2026-10-19: a crashed fix session's tmux pane sat at bash for 17 h while the
+# seat also carried orphan test runs of sessions long finished and ~20 idle
+# Claude Code executor helpers (`node /tmp/.tmpXXXX/local.cjs --ipc-path
+# ….executor.sock`, ~115 MB each). What follows finds what a DEAD session left
+# running; the policy -- which sessions count as dead, and when to sweep --
+# lives in loop.py.
+
+# The executor helper's script and the socket argument that identify it.
+EXECUTOR_SCRIPT = "local.cjs"
+EXECUTOR_SOCKET_SUFFIX = ".executor.sock"
+
+# Processes never signalled whatever their env says: the tmux server hosts
+# EVERY session on the seat (one `tmux new-session -d` server), so killing it
+# would take the live sessions down with the dead one.
+_NEVER_KILL = frozenset({"tmux", "tmux: server", "tini"})
+
+
+@dataclass(frozen=True)
+class Orphan:
+    """One process a dead session left behind: a member of a process tree
+    rooted in a task workspace (`workspace` set), or a parentless executor
+    helper (`workspace` None). `session` is the roster name its env names."""
+
+    proc: Proc
+    session: "str | None"
+    workspace: "TaskWorkspace | None" = None
+
+    @property
+    def command(self) -> str:
+        return " ".join(self.proc.argv)
+
+
+def is_executor(argv: "Sequence[str]") -> bool:
+    """Is this Claude Code's executor helper: a `local.cjs` script given an
+    `….executor.sock` IPC path. Exact tokens, like `is_test_runner`."""
+    return (
+        any(os.path.basename(arg) == EXECUTOR_SCRIPT for arg in argv)
+        and any(arg.endswith(EXECUTOR_SOCKET_SUFFIX) for arg in argv)
+    )
+
+
+def protected_pids(
+    procs: "Mapping[int, Proc]", self_pid: "int | None" = None
+) -> "set[int]":
+    """This process, every ancestor of it, and pid 1: the reaper never
+    signals itself or the chain that started it."""
+    me = os.getpid() if self_pid is None else self_pid
+    protected = {1, me}
+    current = procs.get(me)
+    while current is not None and current.ppid not in protected:
+        protected.add(current.ppid)
+        current = procs.get(current.ppid)
+    return protected
+
+
+def _spared(proc: Proc, protected: "set[int]") -> bool:
+    if not proc.alive or proc.pid in protected:
+        return True
+    head = os.path.basename(proc.argv[0]) if proc.argv else ""
+    return head in _NEVER_KILL or head.startswith("tmux")
+
+
+def find_session_orphans(
+    procs: "Mapping[int, Proc]",
+    hubs: "Sequence[Path]",
+    is_dead: "Callable[[str], bool]",
+    root: "Path | None" = None,
+    self_pid: "int | None" = None,
+) -> "list[Orphan]":
+    """Every process tree rooted in a task workspace of `hubs` whose owner
+    session `is_dead` -- and nothing else.
+
+    A ROOT is a process whose cwd or a path argument sits inside a task
+    workspace (`workspace_of`, the janitor's grammar: `main/`, `.source/` and
+    the hub itself never qualify) AND whose env names a session `is_dead`
+    answers True for. A process naming no session is never a root: it is not
+    a worker's (the seat exports `ALISSA_TMUX_SESSION` to every process a
+    session starts), so an operator's shell parked in a worktree is safe.
+    Below a root, every descendant goes too -- a test worker that moved its
+    cwd to `/tmp`, a child an env-scrubbing helper started -- unless its env
+    names a session that is NOT dead. The tmux server, the reaper itself and
+    its ancestors are never returned."""
+    resolved = []
+    for hub in hubs:
+        try:
+            resolved.append(Path(hub).resolve())
+        except OSError:
+            continue
+    protected = protected_pids(procs, self_pid)
+    sessions: "dict[int, str | None]" = {}
+
+    def session_of(pid: int) -> "str | None":
+        if pid not in sessions:
+            sessions[pid] = roster_name(session_env(pid, root)[0])
+        return sessions[pid]
+
+    found: "dict[int, Orphan]" = {}
+    for proc in sorted(procs.values(), key=lambda p: p.pid):
+        if proc.pid in found or _spared(proc, protected):
+            continue
+        workspace = workspace_of(proc, resolved)
+        if workspace is None:
+            continue
+        session = session_of(proc.pid)
+        if session is None or not is_dead(session):
+            continue
+        for member in descendants(procs, proc.pid):
+            if member.pid in found or _spared(member, protected):
+                continue
+            owner = session_of(member.pid)
+            if owner is not None and not is_dead(owner):
+                continue
+            found[member.pid] = Orphan(
+                proc=member, session=owner or session, workspace=workspace
+            )
+    return sorted(found.values(), key=lambda o: o.proc.pid)
+
+
+def find_parentless_executors(
+    procs: "Mapping[int, Proc]",
+    is_alive: "Callable[[str], bool]",
+    root: "Path | None" = None,
+    self_pid: "int | None" = None,
+) -> "list[Orphan]":
+    """Every executor helper (`is_executor`) whose parent is gone: re-parented
+    to init (pid 1) or to a pid the table no longer holds. One whose env names
+    a session `is_alive` answers True for is spared -- it may still be that
+    session's."""
+    protected = protected_pids(procs, self_pid)
+    found = []
+    for proc in sorted(procs.values(), key=lambda p: p.pid):
+        if _spared(proc, protected) or not is_executor(proc.argv):
+            continue
+        if proc.ppid != 1 and proc.ppid in procs:
+            continue
+        session = roster_name(session_env(proc.pid, root)[0])
+        if session is not None and is_alive(session):
+            continue
+        found.append(Orphan(proc=proc, session=session))
+    return found