cc-session-control 0.6.1__tar.gz → 0.6.3__tar.gz

{cc_session_control-0.6.1/src/cc_session_control.egg-info → cc_session_control-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-session-control
-Version: 0.6.1
+Version: 0.6.3
 Summary: TUI manager for Claude Code sessions and Remote Control
 Author: dzshzx
 License-Expression: MIT

{cc_session_control-0.6.1 → cc_session_control-0.6.3}/src/cc_session_control/__init__.py

@@ -1,3 +1,3 @@
 """cc-session-control — TUI manager for Claude Code sessions and Remote Control."""
 
-__version__ = "0.6.1"
+__version__ = "0.6.3"

{cc_session_control-0.6.1 → cc_session_control-0.6.3}/src/cc_session_control/actions/agent_ops.py

@@ -25,34 +25,11 @@ import os
 import shlex
 import signal
 import time
-from dataclasses import replace
 
 from ..config import cfg
 from ..data import cleanup, liveness, proc, rc, registry
 from ..models import AgentJob, Session
 
-# --- User-facing labels/help (Simplified Chinese, read by the Phase 7 view) ---
-
-TAKEOVER_LABEL = "接回"
-
-# Unified verb table (matches Sessions/RC): Enter/o=接回(primary), s=停止(kill a
-# live thing), d=删除, R=重启(respawn). `r`=刷新 lives in the App-level footer
-# prefix now, so it is NOT repeated here; separators are ` · ` like the other tabs.
-KEYHINTS = "Enter/o 接回 · s 停止 · d 删除 · w 查看 · R 重启"
-
-# Orphan-process risk (R4.5 red line): stop only kills the host pid joined from
-# the sessions registry, killing a --remote-control/bg worker does not always
-# fully reap it, and a live worker with no sessions file can't be located at all.
-HELP = (
-    "后台 agent 生命周期：\n"
-    "  Enter/o 接回(拉回前台，复用 resume；接运行中的 agent 会先确认接管)  w 查看 timeline(只读)\n"
-    "  R 重启(respawn)  d 删除(仅已结束)  s 停止(仅运行中，需确认)  r 刷新\n"
-    "停止/孤儿风险：停止只能杀经 sessions 文件 join 到的 host pid；"
-    "杀 --remote-control/后台 agent 不一定彻底回收，可能残留孤儿进程，需手动确认；"
-    "找不到运行中的后台 agent 的 host pid 时无法停止。"
-)
-
-
 # --- host-pid join (shared by stop_job, remove_job, and the view) -------------
 
 def job_host(job: AgentJob) -> tuple[int | None, bool]:
@@ -68,10 +45,7 @@ def job_host(job: AgentJob) -> tuple[int | None, bool]:
     Injects `/proc` liveness onto the registry rows, then defers to the single
     pure join `registry.host_pid_for_sid` (shared with `snapshot._enrich_jobs`).
     """
-    procs = [
-        replace(sp, proc_alive=proc.pid_alive(sp.pid, sp.proc_start))
-        for sp in registry.read_session_procs()
-    ]
+    procs = liveness.live_session_procs()
     return registry.host_pid_for_sid(job.sid, procs)
 
 
@@ -151,7 +125,7 @@ def resume_takeover(job: AgentJob) -> Session:
 
     Bringing a bg session to the foreground is just a resume of its
     `resume_sid`, so this returns a Session the view feeds to the SAME
-    `app.exit_with_resume` → `do_resume` pipeline used for foreground sessions —
+    `app.exit_with(ResumeIntent)` → `do_resume` pipeline used for foreground sessions —
     all kill/exec/`_resume_plan` logic is reused, none duplicated (R4.4 takeover).
     `pid`/`alive` come from the host join so a live worker is killed first
     (resume = takeover); `current` is computed so the launching session stays

{cc_session_control-0.6.1 → cc_session_control-0.6.3}/src/cc_session_control/actions/session_ops.py

@@ -6,6 +6,7 @@ import os
 import shlex
 import signal
 import time
+from dataclasses import dataclass
 
 from .. import clipboard
 from ..data import proc, rc
@@ -202,6 +203,72 @@ def do_tmux_new(directory: str) -> str | None:
     return rc.run_in_tmux(rc.session_name_for(directory), "claude", cmd)
 
 
+# --- exit intents (the payload crossing the exit-then-exec seam) ------------
+#
+# The TUI cannot run `claude` (or replace itself with tmux) inside the urwid
+# loop, so a resume-family action exits the MainLoop carrying ONE of these
+# intents and `cli._cmd_tui` calls `intent.run()` afterwards. Each intent owns
+# its own finalizer + failure messages, so adding a variant means adding one
+# class here + one view call — app.py and cli.py stay untouched.
+
+class ExitIntent:
+    """What a view asks csctl to do AFTER the MainLoop exits."""
+
+    def run(self) -> None:
+        """Finalize outside the loop; may exec-replace the csctl process."""
+        raise NotImplementedError
+
+
+@dataclass(frozen=True)
+class ResumeIntent(ExitIntent):
+    """Enter/f: bare-terminal resume (execvp; takeover kill inside do_resume)."""
+
+    session: Session
+    fork: bool = False
+
+    def run(self) -> None:
+        do_resume(self.session, fork=self.fork)
+
+
+@dataclass(frozen=True)
+class AttachIntent(ExitIntent):
+    """`t` on a tmux-hosted session: enter its window in place (no kill)."""
+
+    target: str
+
+    def run(self) -> None:
+        if not enter_window(self.target):
+            print(f"Failed to enter tmux window {self.target} (is tmux running?)")
+
+
+@dataclass(frozen=True)
+class TmuxResumeIntent(ExitIntent):
+    """`t` on a dead / bare-terminal session: resume inside tmux, then enter."""
+
+    session: Session
+
+    def run(self) -> None:
+        target = do_tmux_resume(self.session)
+        if target is None:
+            print("Failed to resume the session inside tmux (R10 degraded, or tmux unavailable).")
+        elif not enter_window(target):
+            print(f"Session resumed in tmux window {target}, but attaching failed.")
+
+
+@dataclass(frozen=True)
+class TmuxNewIntent(ExitIntent):
+    """项目-tab `t`: start a NEW claude in tmux, then enter (pure spawn)."""
+
+    directory: str
+
+    def run(self) -> None:
+        target = do_tmux_new(self.directory)
+        if target is None:
+            print("Failed to start a new session inside tmux (is tmux available?).")
+        elif not enter_window(target):
+            print(f"Session started in tmux window {target}, but attaching failed.")
+
+
 def enter_window(target: str) -> bool:
     """Bring `target` ("session:window") to the user's terminal foreground.
 

{cc_session_control-0.6.1 → cc_session_control-0.6.3}/src/cc_session_control/app.py

@@ -6,7 +6,7 @@ import curses
 import os
 import threading
 from collections.abc import Callable
-from typing import Protocol, runtime_checkable
+from typing import TYPE_CHECKING, Protocol, runtime_checkable
 
 import urwid
 
@@ -16,6 +16,9 @@ from .views.agents import AgentsView
 from .views.rc import RCView
 from .views.sessions import SessionsView
 
+if TYPE_CHECKING:
+    from .actions.session_ops import ExitIntent
+
 # D7/R10: shown across all tabs when `/proc` is unavailable (e.g. macOS), where
 # the "current" session can't be determined and destructive ops are refused.
 _DEGRADED_BANNER = "⚠ liveness 降级（无 /proc）：terminate/delete/cleanup 已受限"
@@ -30,7 +33,8 @@ class TabView(Protocol):
     widgets; `apply_data()` runs on the main loop and swaps `_pending` into the
     walker. The `snapshot` is the shared per-cycle world (R11/D8); it is OPTIONAL
     — a view called with `None` self-fetches (back-compat / tests). Adding a tab
-    means honoring every member below.
+    means honoring every member below; subclass `views/_base.py::ListTabView`
+    for the shared walker/overlay/footer plumbing instead of re-writing it.
     """
 
     widget: urwid.Widget
@@ -88,7 +92,7 @@ def _make_screen() -> urwid.raw_display.Screen:
 
 class App:
     def __init__(self) -> None:
-        self.result: tuple | None = None
+        self.result: ExitIntent | None = None
         self._exiting = False
         self._alarm_handle: object | None = None
         self._notify_alarm: object | None = None
@@ -210,32 +214,42 @@ class App:
         self._confirm_yes = None
         self.set_hints(self.views[self._active].keyhints())
 
-    def _exit(self, result: tuple | None = None) -> None:
+    def _exit(self, result: ExitIntent | None = None) -> None:
         self._exiting = True
         if self._alarm_handle:
             self.loop.remove_alarm(self._alarm_handle)
         self.result = result
         raise urwid.ExitMainLoop()
 
-    def exit_with_resume(self, session: object, fork: bool = False) -> None:
-        self._exit(("resume", session, fork))
-
-    def exit_with_attach(self, target: str) -> None:
-        """`t` on a session already living in a tmux window: enter it in place."""
-        self._exit(("attach", target))
+    def exit_with(self, intent: ExitIntent) -> None:
+        """Exit the MainLoop carrying a `session_ops.ExitIntent`.
 
-    def exit_with_tmux_resume(self, session: object) -> None:
-        """`t` on a dead / bare-terminal session: resume it inside tmux, then enter."""
-        self._exit(("tmux_resume", session))
-
-    def exit_with_tmux_new(self, directory: str) -> None:
-        """`t` on a project row: start a NEW claude session in tmux, then enter."""
-        self._exit(("tmux_new", directory))
+        Views construct the intent (they know the verb); `cli._cmd_tui` calls
+        `intent.run()` after the loop ends — resume must exec OUTSIDE urwid, so
+        the finalizer cannot run here. App stays variant-agnostic: adding a
+        resume variant touches only the intent class + the view key handler.
+        """
+        self._exit(intent)
 
     def set_hints(self, hints: str) -> None:
         """Footer = shared prefix + the active tab's keyhints (D1 single source)."""
         self.footer_text.set_text(FOOTER_PREFIX + hints)
 
+    # --- the view-facing façade (views call these, never App internals) ---
+
+    def is_active(self, view: TabView) -> bool:
+        """Whether `view` is the tab currently shown — the one question views
+        may ask about tab state (no peeking at `views`/`_active`)."""
+        return self.views[self._active] is view
+
+    def own_footer(self, widget: urwid.Widget) -> None:
+        """Hand the footer to a view's transient widget (e.g. the filter Edit)."""
+        self.frame.footer = widget
+
+    def release_footer(self) -> None:
+        """Give the footer back to the standard hints line."""
+        self._restore_footer()
+
     def notify(self, msg: str, seconds: float = 3) -> None:
         # The newest notification owns the footer: cancel the previous restore
         # alarm so an older timer can't clear this message early.
@@ -301,7 +315,7 @@ class App:
                 view.apply_data()
         return True
 
-    def run(self) -> tuple | None:
+    def run(self) -> ExitIntent | None:
         self._pipe_fd = self.loop.watch_pipe(self._on_pipe)
         self.views[self._active].load()
         self.set_hints(self.views[self._active].keyhints())

{cc_session_control-0.6.1 → cc_session_control-0.6.3}/src/cc_session_control/cli.py

@@ -87,7 +87,8 @@ def _cmd_rc(args: argparse.Namespace) -> None:
         for p in projects:
             icon = {"running": "[running]", "dead": "[dead   ]", "stopped": "[stopped]"}.get(p.status, p.status)
             auto = "auto" if p.auto_start else "    "
-            print(f"  {icon} {auto}  {p.name}")
+            missing = "" if p.dir_exists else "  (directory missing)"
+            print(f"  {icon} {auto}  {p.name}{missing}")
 
     elif sub == "add":
         proj = args.project
@@ -187,18 +188,13 @@ def _cmd_prune_zombies(args: argparse.Namespace) -> None:
     gated here too — off `/proc` every pid looks dead, so `current` can't be
     determined and we must not even claim the files are sweepable (R10).
     """
-    from dataclasses import replace
-
-    from .data import proc, registry
+    from .data import liveness, proc
     from .data.cleanup import remove_zombie_session_files, select_zombie_pids
 
     if not proc.current_determinable():
         print("Refused: '/proc' unavailable — cannot determine the current session (R10).")
         return
-    procs = [
-        replace(sp, proc_alive=proc.pid_alive(sp.pid, sp.proc_start))
-        for sp in registry.read_session_procs(max_age=0.0)
-    ]
+    procs = liveness.live_session_procs(max_age=0.0)
     cur = proc.ancestor_pids()
     zombies = select_zombie_pids(procs, cur)
     print(f"Would sweep {len(zombies)} zombie session file(s)")
@@ -298,38 +294,15 @@ def _cmd_env(args: argparse.Namespace) -> None:
 
 
 def _cmd_tui(args: argparse.Namespace) -> None:
-    from .actions.session_ops import do_resume, do_tmux_new, do_tmux_resume, enter_window
+    from .actions.session_ops import ExitIntent
     from .app import App
 
-    app = App()
-    result = app.run()
+    result = App().run()
 
-    if not result or not isinstance(result, tuple):
-        return
-    if result[0] == "resume":
-        _, session, fork = result
-        do_resume(session, fork=fork)
-    elif result[0] == "attach":
-        # `t` on a tmux-hosted session: enter its window (exec replaces csctl
-        # outside tmux; switch-client + normal exit inside).
-        if not enter_window(result[1]):
-            print(f"Failed to enter tmux window {result[1]} (is tmux running?)")
-    elif result[0] == "tmux_resume":
-        # `t` on a dead / bare-terminal session: spawn the resume window, then
-        # enter it. Kill semantics (takeover) are handled inside do_tmux_resume.
-        target = do_tmux_resume(result[1])
-        if target is None:
-            print("Failed to resume the session inside tmux (R10 degraded, or tmux unavailable).")
-        elif not enter_window(target):
-            print(f"Session resumed in tmux window {target}, but attaching failed.")
-    elif result[0] == "tmux_new":
-        # `t` on a 项目-tab project row: start a NEW claude session in tmux,
-        # then enter it (nothing is killed — pure spawn).
-        target = do_tmux_new(result[1])
-        if target is None:
-            print("Failed to start a new session inside tmux (is tmux available?).")
-        elif not enter_window(target):
-            print(f"Session started in tmux window {target}, but attaching failed.")
+    # The intent finalizes itself outside the urwid loop (it may exec-replace
+    # csctl — resume/attach) and prints its own failure messages.
+    if isinstance(result, ExitIntent):
+        result.run()
 
 
 def main() -> None:

{cc_session_control-0.6.1 → cc_session_control-0.6.3}/src/cc_session_control/data/cleanup.py

@@ -37,7 +37,6 @@ from __future__ import annotations
 import os
 import shutil
 import time
-from dataclasses import replace
 
 from ..config import cfg
 from ..models import AgentJob, Session, SessionProc
@@ -100,17 +99,6 @@ def _remove_path(path: str) -> bool:
 
 # --- Strategy A: sid-keyed orphan dirs (H1 protected-sid set) --------------
 
-def _live_session_procs(max_age: float = 5.0) -> list[SessionProc]:
-    """Registry session files with `/proc` liveness injected (swallow-error)."""
-    try:
-        return [
-            replace(sp, proc_alive=proc.pid_alive(sp.pid, sp.proc_start))
-            for sp in registry.read_session_procs(max_age=max_age)
-        ]
-    except Exception:
-        return []
-
-
 def known_sids(
     sessions: list[Session],
     session_procs: list[SessionProc],
@@ -163,7 +151,7 @@ def _gather_known(
     self-read swallows its own errors → safe empties.
     """
     if session_procs is None:
-        session_procs = _live_session_procs()
+        session_procs = liveness.live_session_procs()
     if agent_jobs is None:
         try:
             agent_jobs = registry.read_agent_jobs()
@@ -353,7 +341,7 @@ def remove_session(s: Session) -> bool:
         if _remove_path(p):
             removed = True
     # M3: never delete a LIVE agent worker's jobs/<short> dir.
-    _, host_alive = registry.host_pid_for_sid(s.sid, _live_session_procs())
+    _, host_alive = registry.host_pid_for_sid(s.sid, liveness.live_session_procs())
     if not host_alive and _remove_path(_jobs_path(s.sid)):
         removed = True
     return removed

{cc_session_control-0.6.1 → cc_session_control-0.6.3}/src/cc_session_control/data/environments.py

@@ -48,12 +48,18 @@ import contextlib
 import json
 import os
 from collections.abc import Iterator
-from dataclasses import replace
 from typing import Any
 
 from ..config import cfg
-from ..models import AgentJob, BridgeEnv, EnvRecord, RCServer, SessionProc
-from . import proc, registry
+from ..models import (
+    AgentJob,
+    BridgeEnv,
+    EnvRecord,
+    RCServer,
+    SessionProc,
+    split_env_id,
+)
+from . import liveness, registry
 
 try:  # POSIX advisory locking; absent on Windows → degrade to no lock.
     import fcntl
@@ -65,17 +71,51 @@ _RETENTION_SECONDS = 90 * 86400
 _MAX_ENTRIES = 500
 
 
-# --- bridge id parsing -----------------------------------------------------
+# --- observation builder (reads registry + liveness, never rc) -------------
 
-def _split_bridge(bridge: str) -> tuple[str, str]:
-    """`cse_abc` -> (`cse`, `abc`); the suffix is the namespace-local env id."""
-    prefix, sep, suffix = bridge.partition("_")
-    if not sep:
-        return "", ""
-    return prefix, suffix
+def _collect(
+    session_procs: list[SessionProc],
+    agent_jobs: list[AgentJob],
+    rc_servers: list[RCServer] | None,
+    *,
+    alive_gated: bool,
+) -> list[EnvRecord]:
+    """The ONE observation walk over the three env sources (R6).
 
+    `alive_gated=False` → the FILE-REFERENCED membership set (any env a file
+    references, alive or zombie). `alive_gated=True` → the CURRENT set, each
+    source gated by its own liveness rule: `session_*` by the single
+    `liveness.is_rc_exposed` predicate, `cse_*` by a host-alive job or a
+    proc-alive session sharing the job sid, `env_*` by a running RC server.
+    """
+    alive_sids = {sp.sid for sp in session_procs if sp.proc_alive}
+    records: list[EnvRecord] = []
+    for sp in session_procs:
+        if not sp.bridge:
+            continue
+        if alive_gated and not liveness.is_rc_exposed(sp.bridge, sp.proc_alive):
+            continue
+        prefix, key = split_env_id(sp.bridge)
+        if prefix and key:
+            records.append(EnvRecord(prefix=prefix, key=key, bound_sid=sp.sid))
+    for job in agent_jobs:
+        if not job.env_suffix:
+            continue
+        if alive_gated and not (job.host_alive or job.sid in alive_sids):
+            continue
+        records.append(
+            EnvRecord(prefix="cse", key=job.env_suffix, bound_sid=job.sid)
+        )
+    for srv in rc_servers or []:
+        if not srv.env_id:
+            continue
+        if alive_gated and srv.status != "running":
+            continue
+        prefix, key = split_env_id(srv.env_id)
+        if prefix and key:
+            records.append(EnvRecord(prefix=prefix, key=key, bound_sid=None))
+    return records
 
-# --- observation builder (reads registry only, never rc) -------------------
 
 def observe(
     session_procs: list[SessionProc] | None = None,
@@ -102,24 +142,7 @@ def observe(
             session_procs = registry.read_session_procs(max_age=max_age)
         if agent_jobs is None:
             agent_jobs = registry.read_agent_jobs(max_age=max_age)
-        records: list[EnvRecord] = []
-        for sp in session_procs:
-            if not sp.bridge:
-                continue
-            prefix, key = _split_bridge(sp.bridge)
-            if prefix and key:
-                records.append(EnvRecord(prefix=prefix, key=key, bound_sid=sp.sid))
-        for job in agent_jobs:
-            if job.env_suffix:
-                records.append(
-                    EnvRecord(prefix="cse", key=job.env_suffix, bound_sid=job.sid)
-                )
-        for srv in rc_servers or []:
-            if srv.env_id:
-                prefix, sep, key = srv.env_id.partition("_")
-                if sep and prefix and key:
-                    records.append(EnvRecord(prefix=prefix, key=key, bound_sid=None))
-        return records
+        return _collect(session_procs, agent_jobs, rc_servers, alive_gated=False)
     except Exception:
         return []
 
@@ -132,13 +155,14 @@ def observe_live(
 ) -> list[EnvRecord]:
     """Alive-gated "currently exposed" bridge envs (R3/R6) — the CURRENT set.
 
-    Where `observe()` is a bridge-truthy passive collector, this lifts the
-    `_is_rc_exposed` predicate to the env ledger: a bridge is CURRENT only when
-    its owner is alive — `session_*` gated by proc-alive, `cse_*` by a proc-alive
-    session sharing the job sid (host-alive), `env_*` by a running RC server. So a
-    zombie session's stale `bridgeSessionId` is NOT reported as current — it falls
-    through to `orphan_envs` (a manual-delete candidate) instead of overstating
-    the bound count.
+    Where `observe()` is a bridge-truthy passive collector, this applies the
+    single `liveness.is_rc_exposed` predicate (and the per-source gates in
+    `_collect`): a bridge is CURRENT only when its owner is alive — `session_*`
+    gated by proc-alive, `cse_*` by a proc-alive session sharing the job sid
+    (host-alive), `env_*` by a running RC server. So a zombie session's stale
+    `bridgeSessionId` is NOT reported as current — it falls through to
+    `orphan_envs` (a manual-delete candidate) instead of overstating the bound
+    count.
 
     Pure when `session_procs`/`agent_jobs` are supplied (the snapshot path passes
     its already-liveness-resolved data — DI for tests); reads the registry +
@@ -147,30 +171,10 @@ def observe_live(
     """
     try:
         if session_procs is None:
-            session_procs = [
-                replace(sp, proc_alive=proc.pid_alive(sp.pid, sp.proc_start))
-                for sp in registry.read_session_procs(max_age=max_age)
-            ]
+            session_procs = liveness.live_session_procs(max_age=max_age)
         if agent_jobs is None:
             agent_jobs = registry.read_agent_jobs(max_age=max_age)
-        alive_sids = {sp.sid for sp in session_procs if sp.proc_alive}
-        records: list[EnvRecord] = []
-        for sp in session_procs:
-            if sp.bridge and sp.proc_alive:
-                prefix, key = _split_bridge(sp.bridge)
-                if prefix and key:
-                    records.append(EnvRecord(prefix=prefix, key=key, bound_sid=sp.sid))
-        for job in agent_jobs:
-            if job.env_suffix and (job.host_alive or job.sid in alive_sids):
-                records.append(
-                    EnvRecord(prefix="cse", key=job.env_suffix, bound_sid=job.sid)
-                )
-        for srv in rc_servers or []:
-            if srv.env_id and srv.status == "running":
-                prefix, sep, key = srv.env_id.partition("_")
-                if sep and prefix and key:
-                    records.append(EnvRecord(prefix=prefix, key=key, bound_sid=None))
-        return records
+        return _collect(session_procs, agent_jobs, rc_servers, alive_gated=True)
     except Exception:
         return []
 

{cc_session_control-0.6.1 → cc_session_control-0.6.3}/src/cc_session_control/data/liveness.py

@@ -1,7 +1,6 @@
 """Session liveness — the single authority.
 
-Owns the ONE module-global cache for `claude agents --json` (mirrored by the
-`agents.py` re-export shim so terminate's invalidate and scan's read share it).
+Owns the ONE module-global cache for `claude agents --json`.
 `live_index` is a pure merge of already-fetched liveness inputs (registry
 session files with injected proc liveness + `claude agents --json`).
 """
@@ -12,9 +11,10 @@ import json
 import subprocess
 import time
 from collections.abc import Callable
+from dataclasses import replace
 
 from ..models import LiveInfo, SessionProc
-from . import proc
+from . import proc, registry
 
 _cache: dict[str, int | None] | None = None
 _cache_time: float = 0.0
@@ -69,6 +69,23 @@ def invalidate_cache() -> None:
     _cache = None
 
 
+def live_session_procs(max_age: float = 5.0) -> list[SessionProc]:
+    """Registry session files with `/proc` liveness injected — THE assembly point.
+
+    `registry.read_session_procs` deliberately leaves `proc_alive=False` (pure
+    parse, no `/proc`); a `SessionProc.proc_alive` is only trustworthy after
+    this injection. Every consumer must come through here rather than re-inline
+    the `replace(sp, proc_alive=pid_alive(...))` idiom. Swallows errors → [].
+    """
+    try:
+        return [
+            replace(sp, proc_alive=proc.pid_alive(sp.pid, sp.proc_start))
+            for sp in registry.read_session_procs(max_age=max_age)
+        ]
+    except Exception:
+        return []
+
+
 def _source_of(entrypoint: str, kind: str) -> str:
     """Coarse source bucket from the registry entrypoint/kind (D9)."""
     if kind == "bg":
@@ -80,7 +97,7 @@ def _source_of(entrypoint: str, kind: str) -> str:
     return "cli"
 
 
-def _is_rc_exposed(bridge: str | None, pid_alive: bool) -> bool:
+def is_rc_exposed(bridge: str | None, pid_alive: bool) -> bool:
     """Whether session remote control is CURRENTLY exposed (pure predicate).
 
     Exposed iff the bridge id is a truthy string AND the owning process is still

{cc_session_control-0.6.1 → cc_session_control-0.6.3}/src/cc_session_control/data/rc.py

@@ -10,7 +10,7 @@ import subprocess
 import time
 
 from ..config import cfg
-from ..models import EnvRecord, RCProject, RCServer
+from ..models import EnvRecord, RCProject, RCServer, split_env_id
 from . import environments, proc
 
 # Cloud bridge env id printed to a managed server's pane (`environment=env_…`).
@@ -362,18 +362,11 @@ def scan() -> list[RCProject]:
             auto_start=name in enabled,
             rc_at_startup=_read_rc_at_startup(directory),
             spawn_mode=_read_spawn_mode(name),
+            dir_exists=os.path.isdir(directory),
         ))
     return result
 
 
-def _split_env(env_id: str) -> tuple[str, str]:
-    """`env_abc` -> (`env`, `abc`); ("", "") when not a namespaced id."""
-    prefix, sep, suffix = env_id.partition("_")
-    if not sep or not prefix or not suffix:
-        return "", ""
-    return prefix, suffix
-
-
 def _capture_env_id(target: str) -> str:
     """Grep an `env_*` cloud id from a managed server's pane output, or "".
 
@@ -416,7 +409,7 @@ def scan_servers() -> list[RCServer]:
         found = by_pid.get(pid)
         env_id = _capture_env_id(target)
         if env_id:
-            prefix, key = _split_env(env_id)
+            prefix, key = split_env_id(env_id)
             if prefix and key:
                 env_records.append(EnvRecord(prefix=prefix, key=key, bound_sid=None))
         servers.append(RCServer(

{cc_session_control-0.6.1 → cc_session_control-0.6.3}/src/cc_session_control/data/registry.py

@@ -18,7 +18,7 @@ import os
 import time
 
 from ..config import cfg
-from ..models import AgentJob, SessionProc
+from ..models import AgentJob, SessionProc, split_env_id
 
 _sessions_cache: list[SessionProc] | None = None
 _sessions_time: float = 0.0
@@ -33,13 +33,6 @@ def invalidate_cache() -> None:
     _jobs_cache = None
 
 
-def _suffix(bridge: str | None) -> str:
-    """Namespace suffix of a bridge id (`cse_abc` -> `abc`), or ""."""
-    if not bridge or "_" not in bridge:
-        return ""
-    return bridge.split("_", 1)[1]
-
-
 def _parse_session_proc(path: str) -> SessionProc | None:
     try:
         with open(path, errors="ignore") as fh:
@@ -106,7 +99,7 @@ def _parse_agent_job(state_path: str) -> AgentJob | None:
         tempo=d.get("tempo", "") or "",
         cwd=d.get("cwd", "") or "",
         name=d.get("name", "") or "",
-        env_suffix=_suffix(d.get("bridgeSessionId")),
+        env_suffix=split_env_id(d.get("bridgeSessionId"))[1],
         respawn_flags=[str(x) for x in flags],
     )