meshcode 2.11.83__tar.gz → 2.11.84__tar.gz

{meshcode-2.11.83 → meshcode-2.11.84}/PKG-INFO

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

{meshcode-2.11.83 → meshcode-2.11.84}/meshcode/__init__.py

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

{meshcode-2.11.83 → meshcode-2.11.84}/meshcode/hostd.py

@@ -36,6 +36,7 @@ import json
 import os
 import shlex
 import shutil
+import signal as _signal
 import subprocess
 import sys
 import time
@@ -260,8 +261,12 @@ def _spawn_agent(project: str, agent: str, headless: bool = False) -> bool:
         try:
             # `python -m meshcode` (NOT the meshcode.exe shim) so the .exe isn't held open by the
             # agent -> a background `pip install -U` can replace it on Windows (task 14782bb4 #4).
-            subprocess.Popen([sys.executable, "-m", "meshcode", "run", target], **kwargs)
-            _log(f"spawned {target} HEADLESS (no window, {sys.platform}; log={log_path})")
+            proc = subprocess.Popen([sys.executable, "-m", "meshcode", "run", target], **kwargs)
+            # LAUNCH-NO-WINDOW (task 35bee961): record the headless PID so the Stop sweep
+            # (_do_stops) can hard-kill it — a headless agent has NO window for Samuel to
+            # close, so desired_state='stopped' must be enforced by killing the process.
+            _record_headless_pid(target, proc.pid)
+            _log(f"spawned {target} HEADLESS (no window, {sys.platform}; pid={proc.pid}; log={log_path})")
             return True
         except Exception as e:
             _log(f"WARN: headless spawn {target} failed: {e}")
@@ -369,6 +374,151 @@ def _save_state(st: dict) -> None:
         pass
 
 
+# ------------------------------------------------------------------
+# Stop — hard-kill a HEADLESS agent (task 35bee961). A headless agent has no
+# window Samuel can close, so a Stop (desired_state='stopped') that the agent
+# doesn't honor cooperatively (must_exit) would otherwise run forever. We record
+# each headless spawn's PID (persisted across hostd restarts) and kill it when the
+# cloud says it should be stopped but it's still heartbeating.
+# ------------------------------------------------------------------
+
+def _record_headless_pid(target: str, pid: int) -> None:
+    try:
+        st = _load_state()
+        pids = st.get("headless_pids") or {}
+        pids[target] = pid
+        st["headless_pids"] = pids
+        _save_state(st)
+    except Exception:
+        pass
+
+
+def _pid_cmdline(pid: int) -> str:
+    """Best-effort command line for a pid (to avoid killing a reused PID). '' on failure."""
+    try:
+        if sys.platform == "win32":
+            out = subprocess.run(
+                ["wmic", "process", "where", f"ProcessId={pid}", "get", "CommandLine"],
+                capture_output=True, text=True, timeout=5).stdout
+        else:
+            out = subprocess.run(
+                ["ps", "-o", "args=", "-p", str(pid)],
+                capture_output=True, text=True, timeout=5).stdout
+        return out or ""
+    except Exception:
+        return ""
+
+
+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>`.
+    Best-effort; returns [] on any failure."""
+    pids = []
+    try:
+        if sys.platform == "win32":
+            out = subprocess.run(
+                ["wmic", "process", "where", "name='python.exe'", "get", "ProcessId,CommandLine", "/FORMAT:LIST"],
+                capture_output=True, text=True, timeout=8).stdout
+            block_pid = None
+            for line in out.splitlines():
+                line = line.strip()
+                if line.startswith("CommandLine="):
+                    block_pid = ("meshcode" in line and f"run {target}" in line)
+                elif line.startswith("ProcessId=") and block_pid:
+                    try:
+                        pids.append(int(line.split("=", 1)[1]))
+                    except Exception:
+                        pass
+                    block_pid = None
+        else:
+            out = subprocess.run(
+                ["pgrep", "-f", f"meshcode run {target}"],
+                capture_output=True, text=True, timeout=8).stdout
+            for ln in out.split():
+                try:
+                    pids.append(int(ln))
+                except Exception:
+                    pass
+    except Exception:
+        pass
+    return pids
+
+
+def _kill_headless_pid(target: str, pid: int) -> bool:
+    """Hard-kill a recorded headless PID + its child tree. Guards against PID reuse by
+    confirming the cmdline still looks like this meshcode agent. Returns True if killed."""
+    if not pid:
+        return False
+    cl = _pid_cmdline(pid).lower()
+    # Reuse guard: a headless agent's process is either `python -m meshcode run ...`
+    # (Windows: parent stays alive) or `claude ...` (POSIX: execvp'd to the editor). If
+    # we got a cmdline and it's NEITHER, the PID was reused by something unrelated — skip.
+    if cl and ("meshcode" not in cl and "claude" not in cl):
+        _log(f"STOP {target}: pid {pid} cmdline no longer matches (reused) — skip kill")
+        return False
+    try:
+        if sys.platform == "win32":
+            # /T kills the whole tree (python parent + cmd.exe + claude child), /F forces.
+            subprocess.run(["taskkill", "/PID", str(pid), "/T", "/F"],
+                           capture_output=True, timeout=10)
+        else:
+            try:
+                os.killpg(os.getpgid(pid), _signal.SIGTERM)  # start_new_session => own group
+            except Exception:
+                os.kill(pid, _signal.SIGTERM)
+            time.sleep(1.5)
+            try:
+                os.kill(pid, 0)            # still alive?
+                os.killpg(os.getpgid(pid), _signal.SIGKILL)
+            except ProcessLookupError:
+                pass
+            except Exception:
+                try:
+                    os.kill(pid, _signal.SIGKILL)
+                except Exception:
+                    pass
+        _log(f"STOP {target}: hard-killed headless pid {pid}")
+        return True
+    except Exception as e:
+        _log(f"WARN: STOP {target} kill pid {pid} failed: {e}")
+        return False
+
+
+def _do_stops(api_key: str, host_id: str) -> int:
+    """One stop sweep: hard-kill headless agents the cloud marked stopped but that are
+    still alive (cooperative must_exit didn't land). Returns number killed."""
+    res = _rpc("mc_agents_to_stop", {"p_api_key": api_key, "p_host_id": host_id})
+    if not res or not res.get("ok"):
+        return 0
+    agents = res.get("agents") or []
+    if not agents:
+        return 0
+    st = _load_state()
+    pids = st.get("headless_pids") or {}
+    n = 0
+    for a in agents:
+        proj, agent = a.get("project_name"), a.get("agent")
+        if not proj or not agent:
+            continue
+        target = f"{proj}/{agent}"
+        pid = pids.get(target)
+        killed = bool(pid) and _kill_headless_pid(target, pid)
+        if pid and killed:
+            pids.pop(target, None)
+        if not killed:
+            # No recorded PID (spawned by an older hostd / state lost) OR the recorded
+            # PID was stale — discover by command line and kill.
+            for dpid in _discover_agent_pids(target):
+                if _kill_headless_pid(target, dpid):
+                    killed = True
+            pids.pop(target, None)
+        if killed:
+            n += 1
+    st["headless_pids"] = pids
+    _save_state(st)
+    return n
+
+
 def _do_recycles(api_key: str, host_id: str) -> int:
     """Uptime-based recycle at task boundary. Returns number recycled."""
     cfg = _rpc("mc_host_config_get", {"p_api_key": api_key, "p_host_id": host_id})
@@ -833,9 +983,10 @@ def cmd_hostd(args: list) -> int:
                         relaunched = _do_respawns(api_key, host_id)
                         recycled = _do_recycles(api_key, host_id)
                         ver_recycled = _do_version_recycles(api_key, host_id)
+                        stopped = _do_stops(api_key, host_id)
                         _up = int(time.monotonic() - _spawn_mono)
-                        if relaunched or recycled or ver_recycled:
-                            _log(f"sweep done (uptime={_up}s) — {relaunched} respawned, {recycled} recycled, {ver_recycled} version-recycled")
+                        if relaunched or recycled or ver_recycled or stopped:
+                            _log(f"sweep done (uptime={_up}s) — {relaunched} respawned, {recycled} recycled, {ver_recycled} version-recycled, {stopped} stopped")
                         elif time.monotonic() - _last_alive_log >= 60:
                             _log(f"alive — uptime={_up}s")
                             _last_alive_log = time.monotonic()

{meshcode-2.11.83 → meshcode-2.11.84}/meshcode/protocol_handler.py

@@ -117,9 +117,12 @@ def _spawn_terminal_windows(cmd: str) -> tuple[bool, str]:
             wt = str(cand)
     if wt:
         try:
-            # `wt -w 0 nt` opens a new tab in existing window (Samuel-confirmed visible+focused
-            # on his box — task 35bee961 live test: keep -w 0).
-            subprocess.Popen([wt, "-w", "0", "nt", "cmd", "/k", cmd])
+            # LAUNCH-NO-WINDOW (task 35bee961, commander-corrected): `-w new` forces a
+            # BRAND-NEW Windows Terminal window (freshly created => FOREGROUND/focused), which
+            # is what Samuel wants ("ventana nueva ENFOCADA"). The old `-w 0 nt` opened a tab in
+            # the most-recently-used window — frequently minimized/background, so the launch
+            # looked like "nada pasó".
+            subprocess.Popen([wt, "-w", "new", "nt", "cmd", "/k", cmd])
             return True, "wt"
         except Exception as e:
             return False, f"wt.exe: {e}"

{meshcode-2.11.83 → meshcode-2.11.84}/meshcode.egg-info/PKG-INFO

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

meshcode-2.11.84/meshcode.egg-info/SOURCES.txt

@@ -0,0 +1,88 @@
+README.md
+pyproject.toml
+meshcode/__init__.py
+meshcode/__main__.py
+meshcode/_stop_hook_template.py
+meshcode/ascii_art.py
+meshcode/atomic_push.py
+meshcode/claude_update.py
+meshcode/cli.py
+meshcode/comms_v4.py
+meshcode/compat.py
+meshcode/daemon.py
+meshcode/date_parse.py
+meshcode/doctor.py
+meshcode/error_hints.py
+meshcode/exceptions.py
+meshcode/hostd.py
+meshcode/invites.py
+meshcode/launcher.py
+meshcode/launcher_install.py
+meshcode/preferences.py
+meshcode/protocol_handler.py
+meshcode/protocol_v2.py
+meshcode/quickstart.py
+meshcode/rpc_allowlist.py
+meshcode/run_agent.py
+meshcode/secrets.py
+meshcode/self_update.py
+meshcode/setup_clients.py
+meshcode/supervisor.py
+meshcode/up.py
+meshcode/upload.py
+meshcode.egg-info/PKG-INFO
+meshcode.egg-info/SOURCES.txt
+meshcode.egg-info/dependency_links.txt
+meshcode.egg-info/entry_points.txt
+meshcode.egg-info/requires.txt
+meshcode.egg-info/top_level.txt
+meshcode/meshcode_mcp/__init__.py
+meshcode/meshcode_mcp/__main__.py
+meshcode/meshcode_mcp/backend.py
+meshcode/meshcode_mcp/realtime.py
+meshcode/meshcode_mcp/server.py
+meshcode/meshcode_mcp/sleep_signals.py
+meshcode/meshcode_mcp/test_backend.py
+meshcode/meshcode_mcp/test_boot_timing.py
+meshcode/meshcode_mcp/test_install_guard.py
+meshcode/meshcode_mcp/test_prefs_claude_version.py
+meshcode/meshcode_mcp/test_realtime.py
+meshcode/meshcode_mcp/test_server_wrapper.py
+meshcode/scripts/check_secrets.py
+meshcode/scripts/race_rate_harness.py
+tests/test_auto_update_hardening.py
+tests/test_autonomous_closegap_1.py
+tests/test_autonomous_closegap_2.py
+tests/test_autonomous_closegap_3.py
+tests/test_autonomous_prompt_inject.py
+tests/test_boot_bug_regression.py
+tests/test_color_truecolor.py
+tests/test_core.py
+tests/test_cross_agent_messaging.py
+tests/test_date_parse.py
+tests/test_doctor.py
+tests/test_epistemic_v1_python_sdk.py
+tests/test_epistemic_v1_stop_conditions.py
+tests/test_esc_deaf_state.py
+tests/test_exceptions.py
+tests/test_file_upload.py
+tests/test_init_device_code.py
+tests/test_install_guard.py
+tests/test_lease_sigterm_release.py
+tests/test_mark_read_batch.py
+tests/test_marketplace_ratings.py
+tests/test_migration_integrity.py
+tests/test_realtime_event_freshness.py
+tests/test_rls_cross_tenant.py
+tests/test_rpc_grants.py
+tests/test_rpc_migrations.py
+tests/test_run_agent_dry_run.py
+tests/test_run_agent_no_server_import.py
+tests/test_security_regressions.py
+tests/test_self_update_user_site.py
+tests/test_sentinel.py
+tests/test_setup_path.py
+tests/test_sleep_signals.py
+tests/test_status_enum_coverage.py
+tests/test_stay_on_loop_hook.py
+tests/test_wait_open_tasks_contradiction.py

meshcode-2.11.84/meshcode.egg-info/top_level.txt

@@ -0,0 +1 @@
+meshcode

{meshcode-2.11.83 → meshcode-2.11.84}/pyproject.toml

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