meshcode 2.11.135__tar.gz → 2.11.136__tar.gz

{meshcode-2.11.135 → meshcode-2.11.136}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.11.135
+Version: 2.11.136
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT

{meshcode-2.11.135 → meshcode-2.11.136}/meshcode/__init__.py

@@ -1,5 +1,5 @@
 """MeshCode — Real-time communication between AI agents."""
-__version__ = "2.11.135"
+__version__ = "2.11.136"
 
 # Exception hierarchy — eagerly imported (lightweight, no deps)
 from meshcode.exceptions import (  # noqa: F401

{meshcode-2.11.135 → meshcode-2.11.136}/meshcode/hostd.py

@@ -1330,6 +1330,46 @@ def _own_ancestry_pids() -> set:
     return anc
 
 
+def _run_token_rx(target: str):
+    """`meshcode run <target>` token regex accepting BOTH spawn forms (task 3ed8781d).
+
+    BARE-NAME GAP (the Windows stop-por-RPC zombie, Samuel 2026-06-11): hostd spawns
+    `run "project/agent"` but the FE Start click goes through protocol_handler's
+    cmd_launch_batch, which spawns `run "agent"` (bare). The old per-call-site token
+    (`run <project/agent>`) could NEVER match a bare-spawned session, so stop/force-kill/
+    reap/reconcile discovery silently found nothing for protocol-launched agents — the
+    session survived every Stop, the relaunch opened a NEW wt tab on top, and Samuel's
+    box accumulated up to 3 sessions/tabs per agent.
+
+    - target 'proj/agent': matches `run [\"']?(proj/)?agent` — both qualified and bare.
+    - target 'agent' (bare, the protocol reconcile caller): matches `run [\"']?(<any>/)?agent`
+      — both forms again, since a survivor may have been hostd-spawned.
+    All forms keep the optional opening quote (QUOTED-TARGET FIX 14e0760c) and the
+    trailing lookahead, so 'qa' can never prefix-match 'qa-2'."""
+    proj, _, agent = target.rpartition("/")
+    if proj:
+        pfx = r"(?:" + re.escape(proj) + r"/)?"
+    else:
+        pfx = r"(?:[^\s\"']*/)?"
+    return re.compile(r"run\s+[\"']?" + pfx + re.escape(agent) + r"(?=\s|$|[\"'])")
+
+
+def _bare_match_is_foreign(cl: str, cwd: str, target: str) -> bool:
+    """Cross-project guard for BARE-token matches (task 3ed8781d). When `target` is
+    project-qualified but the candidate cmdline only carries the bare agent name,
+    a same-named agent of ANOTHER mesh on this box could collide. The workspace
+    cwd (`~/meshcode/<project>-<agent>`) disambiguates: if the cwd basename looks
+    like a workspace of this agent but a DIFFERENT project, skip it. Unreadable
+    cwd or qualified-token matches are never rejected (best-effort guard only)."""
+    proj, _, agent = target.rpartition("/")
+    if not proj or f"{proj}/{agent}" in (cl or ""):
+        return False  # qualified match — unambiguous
+    # separator-agnostic last path component (a Windows cwd seen from tests/tools
+    # running under POSIX must split the same way)
+    base = re.split(r"[\\/]", (cwd or "").rstrip("/\\"))[-1]
+    return base.endswith(f"-{agent}") and base != f"{proj}-{agent}"
+
+
 def _discover_agent_pids(target: str) -> list:
     """Fallback PID discovery by command line, for agents spawned before this hostd
     (no recorded PID) or after a state-file loss. Matches `meshcode run <target>`.
@@ -1353,9 +1393,16 @@ def _discover_agent_pids(target: str) -> list:
     (`run\\s+<target>`) NEVER matched on Windows — stop/force-kill discovery silently
     found nothing, which is how stopped sessions survived as zombies. The token now
     accepts one optional opening quote; the trailing lookahead still forbids any
-    'qa' vs 'qa-2' prefix collision."""
+    'qa' vs 'qa-2' prefix collision.
+
+    BARE-NAME FIX (task 3ed8781d): the token now comes from _run_token_rx, which ALSO
+    matches protocol-handler bare-name spawns (`run "agent"`) — the form every FE Start
+    click produces. Bare matches are cwd-guarded against same-named agents of another
+    mesh (psutil path only; the native fallbacks accept the regex as-is, documented
+    tradeoff: a zombie that survives every stop is the live bug, the cross-mesh
+    same-name collision is the rare one)."""
     pids = []
-    tok = re.compile(r"run\s+[\"']?" + re.escape(target) + r"(?=\s|$|[\"'])")
+    tok = _run_token_rx(target)
     ps = _psutil()
     if ps is not None:
         try:
@@ -1366,10 +1413,23 @@ def _discover_agent_pids(target: str) -> list:
                         continue
                     cl = " ".join(p.cmdline() or [])
                     if "meshcode" in cl and tok.search(cl) and "python" in (p.name() or "").lower():
+                        try:
+                            cwd = p.cwd() or ""
+                        except Exception:
+                            cwd = ""
+                        if _bare_match_is_foreign(cl, cwd, target):
+                            _log(f"DISCOVER {target}: pid {p.pid} bare-name match belongs to "
+                                 f"another project (cwd {cwd!r}) — skip")
+                            continue
                         pids.append(p.pid)
                 except Exception:
                     continue
-            return pids
+            # GHOST-TERMINAL fix (91201315) APPLIES HERE TOO (task 3ed8781d): the old
+            # `return pids` skipped the POSIX launcher-children fallback whenever
+            # psutil was importable — re-defeating the '0 stopped forever' hole on
+            # every box with psutil. Fall through to the shared tail instead.
+            return pids + ([p for p in _discover_launcher_child_pids(target)
+                            if p not in pids] if sys.platform != "win32" else [])
         except Exception:
             pids = []  # psutil enumeration itself broke — fall through to native
     try:
@@ -1389,8 +1449,11 @@ def _discover_agent_pids(target: str) -> list:
                         pass
                     block_pid = None
         else:
+            # task 3ed8781d: pattern WITHOUT the target so bare-name spawns
+            # (`run "agent"`) are candidates too; the exact tok filter below
+            # keeps the kill set tight.
             out = subprocess.run(
-                ["pgrep", "-f", f"meshcode run {target}"],
+                ["pgrep", "-f", "meshcode.* run "],
                 capture_output=True, text=True, timeout=8).stdout
             for ln in out.split():
                 try:
@@ -1474,12 +1537,17 @@ def _discover_serve_pids(target: str) -> list:
     sibling agent's serve (same project, different agent) can never match. psutil-only
     (environ() needs a real process handle); without psutil returns [] — degraded but
     safe, and the session-root tree kill still takes any serve that is STILL parented
-    under the session."""
+    under the session.
+
+    BARE-TARGET support (task 3ed8781d): a bare `agent` target (the protocol-handler
+    relaunch reconcile) matches on MESHCODE_AGENT alone — the relaunch click means
+    'fresh session of THIS agent on this box', so any project's orphan of that name
+    is a survivor to clear. Qualified targets keep the exact two-field match."""
     ps = _psutil()
     if ps is None:
         return []
-    proj, _, agent = target.partition("/")
-    if not proj or not agent:
+    proj, _, agent = target.rpartition("/")
+    if not agent:
         return []
     own = _own_pid()
     out = []
@@ -1492,7 +1560,8 @@ def _discover_serve_pids(target: str) -> list:
                 if "meshcode" not in cl or "serve" not in cl or "meshcode_mcp" not in cl:
                     continue
                 env = p.environ() or {}
-                if env.get("MESHCODE_PROJECT") == proj and env.get("MESHCODE_AGENT") == agent:
+                if env.get("MESHCODE_AGENT") == agent and \
+                        (not proj or env.get("MESHCODE_PROJECT") == proj):
                     out.append(p.pid)
             except Exception:
                 continue  # process vanished / access denied — never block the sweep
@@ -1507,10 +1576,16 @@ def _kill_heartbeat_fork(target: str) -> None:
     would keep POSTing and show a stopped agent 'online'. Stop it by its pidfile
     heartbeat_<proj>_<name>.pid. Best-effort."""
     try:
-        proj, _, agent = target.partition("/")
+        proj, _, agent = target.rpartition("/")
         if not agent:
             return
-        pidf = STATE_DIR / f"heartbeat_{proj}_{agent}.pid"
+        if proj:
+            pidf = STATE_DIR / f"heartbeat_{proj}_{agent}.pid"
+        else:
+            # bare target (task 3ed8781d, protocol-handler reconcile): project
+            # unknown — glob the agent's pidfile across projects (first hit).
+            cands = sorted(STATE_DIR.glob(f"heartbeat_*_{agent}.pid"))
+            pidf = cands[0] if cands else STATE_DIR / f"heartbeat__{agent}.pid"
         if not pidf.exists():
             return
         try:
@@ -1542,15 +1617,25 @@ def _write_stop_marker(target: str) -> None:
     (6/6 needed SIGKILL), so the wrapper sees rc=137 — indistinguishable from
     a crash by exit code alone. The wrapper treats a non-zero rc as a CLEAN
     stop (closes its own tab) only when this marker exists and is fresh;
-    real crashes have no marker and keep their scrollback open. Best-effort."""
+    real crashes have no marker and keep their scrollback open. Best-effort.
+
+    DUAL-LABEL FIX (task 3ed8781d, Windows tab accumulation): the launcher script
+    computes its marker name from ITS OWN spawn cmd — hostd spawns carry
+    'project/agent' (label 'project_agent') but protocol-handler launch-batch spawns
+    carry the BARE agent name (label 'agent'). A stop that only stamped the
+    target-form marker left a bare-spawned wrapper seeing rc!=0 WITHOUT its marker
+    -> `pause` -> dead wt tab held open forever; relaunch then added a fresh tab
+    (Samuel: 'demasiadas tabs'). Stamp BOTH labels — both are consumed/GC'd."""
     try:
-        # EXACT mirror of protocol_handler._launcher_label's sanitization —
-        # the wrapper computes the same name at generation time.
-        safe = re.sub(r"[^A-Za-z0-9_.-]", "_", target.strip()).strip("_")[:80]
-        if not safe:
-            return
         STATE_DIR.mkdir(parents=True, exist_ok=True)
-        (STATE_DIR / f"stopmark_{safe}").write_text(str(time.time()), encoding="utf-8")
+        labels = {target.strip(), target.rpartition("/")[2].strip()}
+        for raw in labels:
+            # EXACT mirror of protocol_handler._launcher_label's sanitization —
+            # the wrapper computes the same name at generation time.
+            safe = re.sub(r"[^A-Za-z0-9_.-]", "_", raw).strip("_")[:80]
+            if not safe:
+                continue
+            (STATE_DIR / f"stopmark_{safe}").write_text(str(time.time()), encoding="utf-8")
     except Exception:
         pass
 
@@ -1569,9 +1654,10 @@ def _session_root_pid(target: str, pid: int) -> int:
     ps = _psutil()
     if ps is None:
         return pid
-    # optional opening quote: the Windows spawn cmdline quotes the target (see
-    # _discover_agent_pids QUOTED-TARGET FIX) — same token everywhere.
-    tok = re.compile(r"run\s+[\"']?" + re.escape(target) + r"(?=\s|$|[\"'])")
+    # Same token everywhere (task 3ed8781d): _run_token_rx accepts the quoted AND the
+    # bare-name spawn forms, so the climb also reaches the wrapper of a protocol-
+    # handler-launched session (`run "agent"`).
+    tok = _run_token_rx(target)
     anc = _own_ancestry_pids()
     root = pid
     try:

{meshcode-2.11.135 → meshcode-2.11.136}/meshcode/protocol_handler.py

@@ -1047,6 +1047,7 @@ def cmd_launch_batch(agent_names: Iterable[str], repo_path: Optional[str] = None
 
     launched: list[str] = []
     skipped: list[dict] = []
+    reconciled: dict = {}   # agent -> surviving session trees killed pre-spawn (3ed8781d)
 
     # Resolve `meshcode` binary path (CLI wrapper installed by pip).
     mc_bin = shutil.which("meshcode") or "meshcode"
@@ -1094,6 +1095,22 @@ def cmd_launch_batch(agent_names: Iterable[str], repo_path: Optional[str] = None
             skipped.append({"agent": name,
                             "reason": f"cooldown {_LAUNCH_COOLDOWN_S}s (recently launched)"})
             continue
+        # RELAUNCH RECONCILIATION (task 3ed8781d — the hostd respawn path has had this
+        # since 14e0760c, but THIS path — every FE Start click — never did): a
+        # stopped-but-surviving session (stale heartbeat, so DEDUP 1 doesn't see it)
+        # would get a fresh session spawned ON TOP, splitting the inbox and stacking
+        # wt tabs (Samuel's Windows box: up to 3 sessions/tabs per agent). Kill any
+        # surviving session tree of this agent BEFORE opening the new one — strictly
+        # pre-spawn, so the fresh session can never be in the kill set. hostd's
+        # machinery (token discovery + tree kill + stop-marker so the old tab
+        # self-closes) accepts bare names since task 3ed8781d. Best-effort.
+        try:
+            from meshcode import hostd as _hostd
+            _rec = _hostd._reconcile_target(name)
+            if _rec:
+                reconciled[name] = _rec
+        except Exception:
+            pass
         # PER-PLATFORM quoting (mesh-core FIX2): cmd.exe wants double-quotes, not POSIX shlex
         # single-quotes (cmd.exe passes single-quotes through literally -> file-not-found).
         if sys.platform == "win32":
@@ -1113,6 +1130,8 @@ def cmd_launch_batch(agent_names: Iterable[str], repo_path: Optional[str] = None
         "agents": launched,
         "skipped": skipped,
     }
+    if reconciled:
+        out["reconciled"] = reconciled
     print(json.dumps(out))
     return 0 if not skipped else 1
 

{meshcode-2.11.135 → meshcode-2.11.136}/meshcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.11.135
+Version: 2.11.136
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT

{meshcode-2.11.135 → meshcode-2.11.136}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "meshcode"
-version = "2.11.135"
+version = "2.11.136"
 description = "Real-time communication between AI agents — Supabase-backed CLI"
 readme = "README.md"
 license = {text = "MIT"}

{meshcode-2.11.135 → meshcode-2.11.136}/tests/test_hostd_zombie_sessions.py

@@ -34,13 +34,17 @@ class FakeNoSuchProcess(Exception):
 
 
 class FakeProc:
-    def __init__(self, table, pid, ppid, cmdline, name="", env=None):
+    def __init__(self, table, pid, ppid, cmdline, name="", env=None, cwd=""):
         self._table = table
         self.pid = pid
         self._ppid = ppid
         self._cmdline = cmdline
         self._name = name or (cmdline.split()[0] if cmdline else "")
         self._env = env or {}
+        self._cwd = cwd
+
+    def cwd(self):
+        return self._cwd
 
     # --- psutil.Process API surface used by hostd ---
     def cmdline(self):
@@ -81,8 +85,8 @@ class FakePsutil:
         self.live = set()
         self.killed = []   # kill order, for pre-spawn ordering assertions
 
-    def add(self, pid, ppid, cmdline, name="", env=None):
-        self.procs[pid] = FakeProc(self, pid, ppid, cmdline, name=name, env=env)
+    def add(self, pid, ppid, cmdline, name="", env=None, cwd=""):
+        self.procs[pid] = FakeProc(self, pid, ppid, cmdline, name=name, env=env, cwd=cwd)
         self.live.add(pid)
         return self.procs[pid]
 
@@ -427,5 +431,139 @@ class DiscoveryTests(ZombieFixBase):
         self.assertEqual(hostd._discover_agent_pids(TARGET), [qa["run"]])
 
 
+class BareNameSpawnTests(ZombieFixBase):
+    """task 3ed8781d — the Windows stop-por-RPC + relaunch zombie. protocol_handler's
+    cmd_launch_batch (every FE Start click) spawns `meshcode run "agent"` (BARE name);
+    the old per-site token (`run <project/agent>`) never matched it, so stop/reap/
+    reconcile found nothing -> sessions + wt tabs stacked up to 3 per agent."""
+
+    def add_bare_session(self, base, agent="qa", cwd=""):
+        """Protocol-handler-shaped tree: cmd wrapper runs the launcher SCRIPT (no
+        token in its cmdline post-a4001d59) -> python `run "<agent>"` (bare)."""
+        self.ps.add(50, 1, "WindowsTerminal.exe", name="WindowsTerminal.exe")
+        self.ps.add(base, 50,
+                    f'cmd /c C:\\u\\.meshcode\\launchers\\{agent}.cmd',
+                    name="cmd.exe")
+        self.ps.add(base + 1, base, f'C:\\py\\python.exe -m meshcode run "{agent}"',
+                    name="python.exe", cwd=cwd)
+        self.ps.add(base + 2, base + 1, "C:\\claude\\claude.exe --session x",
+                    name="claude.exe")
+        return {"cmd": base, "run": base + 1, "claude": base + 2}
+
+    def test_qualified_target_discovers_bare_spawn(self):
+        """LOAD-BEARING: hostd stop sweeps (target 'proj/agent') must find a
+        protocol-launched session whose cmdline is `run "agent"`."""
+        self.add_hostd()
+        s = self.add_bare_session(100)
+        self.assertEqual(hostd._discover_agent_pids(TARGET), [s["run"]])
+
+    def test_bare_target_discovers_qualified_spawn(self):
+        """Reverse direction: the protocol-handler relaunch reconcile (bare 'qa')
+        must find a hostd-spawned session (`run "mesh-core/qa"`)."""
+        self.add_hostd()
+        qa = self.add_session(100)
+        self.assertEqual(hostd._discover_agent_pids("qa"), [qa["run"]])
+
+    def test_bare_forms_keep_prefix_safety(self):
+        """'qa' must never match 'qa-2' in either form."""
+        self.add_hostd()
+        self.ps.add(601, 1, 'python.exe -m meshcode run "qa-2"', name="python.exe")
+        self.ps.add(602, 1, 'python.exe -m meshcode run "mesh-core/qa-2"', name="python.exe")
+        self.assertEqual(hostd._discover_agent_pids(TARGET), [])
+        self.assertEqual(hostd._discover_agent_pids("qa"), [])
+
+    def test_bare_match_foreign_project_cwd_is_skipped(self):
+        """Cross-mesh guard: a bare-spawned 'qa' whose cwd is ANOTHER project's
+        workspace (~/meshcode/<other>-qa) is not killable via 'mesh-core/qa'."""
+        self.add_hostd()
+        self.add_bare_session(100, cwd="C:\\u\\meshcode\\other-mesh-qa")
+        self.assertEqual(hostd._discover_agent_pids(TARGET), [])
+
+    def test_bare_match_own_project_cwd_is_accepted(self):
+        self.add_hostd()
+        s = self.add_bare_session(100, cwd="C:\\u\\meshcode\\mesh-core-qa")
+        self.assertEqual(hostd._discover_agent_pids(TARGET), [s["run"]])
+
+    def test_stop_kills_bare_spawned_session_tree(self):
+        """End-to-end: desired_state='stopped' takes down the protocol-launched
+        tree (python run + claude); the launcher cmd wrapper SURVIVES by design
+        (no token in its cmdline) to run the stopmark epilogue -> tab self-closes."""
+        self.add_hostd()
+        s = self.add_bare_session(100)
+        self.rpc.script("mc_agents_to_stop",
+                        {"ok": True, "agents": [{"project_name": "mesh-core", "agent": "qa"}]})
+        n = hostd._do_stops("k", "h")
+        self.assertEqual(n, 1)
+        self.assertNotIn(s["run"], self.ps.live, "bare-spawned run survived the stop")
+        self.assertNotIn(s["claude"], self.ps.live, "bare-spawned claude survived the stop")
+        self.assertIn(50, self.ps.live, "terminal host was killed")
+
+    def test_serve_discovery_bare_target_matches_agent_env(self):
+        self.ps.add(200, 1, "python.exe -m meshcode.meshcode_mcp serve", name="python.exe",
+                    env={"MESHCODE_PROJECT": "mesh-core", "MESHCODE_AGENT": "qa"})
+        self.assertEqual(hostd._discover_serve_pids("qa"), [200])
+        self.assertEqual(hostd._discover_serve_pids("backend"), [])
+
+
+class StopMarkerDualLabelTests(unittest.TestCase):
+    """task 3ed8781d — _write_stop_marker must stamp BOTH the target-form label
+    (hostd spawns) and the bare-agent label (protocol-handler spawns): the launcher
+    script checks the label derived from ITS OWN spawn cmd, and a missing marker
+    flips an intentional stop into a `pause`-held dead wt tab."""
+
+    def test_writes_both_labels(self):
+        import tempfile
+        from pathlib import Path
+        with tempfile.TemporaryDirectory() as td:
+            with mock.patch.object(hostd, "STATE_DIR", Path(td)):
+                hostd._write_stop_marker("mesh-core/qa")
+                names = sorted(p.name for p in Path(td).glob("stopmark_*"))
+        self.assertEqual(names, ["stopmark_mesh-core_qa", "stopmark_qa"])
+
+    def test_bare_target_writes_single_label(self):
+        import tempfile
+        from pathlib import Path
+        with tempfile.TemporaryDirectory() as td:
+            with mock.patch.object(hostd, "STATE_DIR", Path(td)):
+                hostd._write_stop_marker("qa")
+                names = sorted(p.name for p in Path(td).glob("stopmark_*"))
+        self.assertEqual(names, ["stopmark_qa"])
+
+
+class LaunchBatchReconcileTests(unittest.TestCase):
+    """task 3ed8781d — cmd_launch_batch (every FE Start click / launch-url) must
+    reconcile surviving sessions pre-spawn, like the hostd respawn path has since
+    14e0760c."""
+
+    def _run(self, reconcile_side_effect):
+        from meshcode import protocol_handler as ph
+        import json as _json
+        printed = []
+        with mock.patch.object(ph, "live_agent_names", lambda names, project=None: set()), \
+             mock.patch.object(ph, "_read_cooldowns", lambda: {}), \
+             mock.patch.object(ph, "_record_spawn", lambda n, now=None: None), \
+             mock.patch.object(ph, "_spawn_terminal", lambda cmd: (True, "wt(fleet-tab)")), \
+             mock.patch.object(hostd, "_reconcile_target", reconcile_side_effect), \
+             mock.patch("builtins.print", lambda *a, **k: printed.append(a[0] if a else "")):
+            rc = ph.cmd_launch_batch(["qa"])
+        return rc, _json.loads(printed[-1])
+
+    def test_reconcile_called_before_spawn_and_reported(self):
+        calls = []
+        rc, out = self._run(lambda name: calls.append(name) or 2)
+        self.assertEqual(rc, 0)
+        self.assertEqual(calls, ["qa"])
+        self.assertEqual(out.get("reconciled"), {"qa": 2})
+        self.assertEqual(out["agents"], ["qa"])
+
+    def test_reconcile_failure_never_blocks_launch(self):
+        def boom(name):
+            raise RuntimeError("psutil exploded")
+        rc, out = self._run(boom)
+        self.assertEqual(rc, 0)
+        self.assertEqual(out["agents"], ["qa"])
+        self.assertNotIn("reconciled", out)
+
+
 if __name__ == "__main__":
     unittest.main()