meshcode 2.11.110__tar.gz → 2.11.111rc1__tar.gz

{meshcode-2.11.110 → meshcode-2.11.111rc1}/PKG-INFO

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

{meshcode-2.11.110 → meshcode-2.11.111rc1}/meshcode/__init__.py

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

{meshcode-2.11.110 → meshcode-2.11.111rc1}/meshcode/hostd.py

@@ -159,6 +159,17 @@ STATE_DIR = Path.home() / ".meshcode"
 HOST_ID_PATH = STATE_DIR / "host_id"
 LOG_PATH = STATE_DIR / "hostd.log"
 
+# BOOT-AUTOSTART GATE (task b6da0d54, Samuel: "terminals open by themselves at boot").
+# hostd is launched at OS logon (Task Scheduler / launchd). On a fresh start it must NOT
+# auto-respawn agents that were merely left desired_state='running' by a PRIOR session —
+# that's the "terminals pop at boot" bug. We record hostd's own start time; an agent whose
+# last heartbeat PREDATES this start (or who never heartbeated) is a boot-stale leftover and
+# is skipped (explicit launch required). An agent that was alive AFTER this start and then
+# died = a real crash -> respawned (crash-recovery preserved). Opt back into the old
+# auto-launch-everything behavior with MESHCODE_BOOT_AUTOSTART=1.
+_HOSTD_STARTED_AT = time.time()
+_BOOT_AUTOSTART = os.environ.get("MESHCODE_BOOT_AUTOSTART", "").strip().lower() in ("1", "true", "yes", "on")
+
 def _env_poll_interval() -> int:
     # task 399d7b51 SPEED: poll faster so click->desired_state->spawn latency drops (was 45s).
     # Env-configurable (survives upgrade); floor 3s so we never hammer the DB.
@@ -516,6 +527,19 @@ def _do_respawns(api_key: str, host_id: str) -> int:
             # do NOT re-record here (that would inflate the count on a mere rate-limit skip).
             _log(f"SKIP respawn {proj}/{agent}: not allowed (count={c.get('respawn_count')}, rate-limited/at-cap)")
             continue
+        # BOOT-AUTOSTART GATE (task b6da0d54): don't auto-launch an agent whose last heartbeat
+        # PREDATES this hostd start (or never heartbeated) — that's a boot-stale 'running' leftover
+        # from a prior session, NOT a live-then-crashed agent. Skip it (explicit launch required) so
+        # rebooting / hostd-restart does NOT pop terminals. An agent alive AFTER startup that died =
+        # crash -> falls through to respawn (crash-recovery preserved). MESHCODE_BOOT_AUTOSTART=1 opts out.
+        if not _BOOT_AUTOSTART:
+            _hb_age = c.get("heartbeat_age_s")
+            _hostd_uptime = time.time() - _HOSTD_STARTED_AT
+            if _hb_age is None or _hb_age >= _hostd_uptime:
+                _log(f"BOOT-AUTOSTART OFF: skip auto-respawn {proj}/{agent} (no heartbeat since hostd "
+                     f"start — boot-stale 'running' leftover; explicit launch required). "
+                     f"Set MESHCODE_BOOT_AUTOSTART=1 to auto-launch at boot.")
+                continue
         # RECYCLE FAST-PATH (task c0fc5597): a recycle-exited agent (recycle_fast) is relaunched
         # PROMPTLY (the RPC returned it at a 15s stale gate, not STALE_SECONDS) and recorded as a
         # RECYCLE (mc_record_recycle), NEVER against the crash respawn cap.

{meshcode-2.11.110 → meshcode-2.11.111rc1}/meshcode/meshcode_mcp/server.py

@@ -1591,6 +1591,105 @@ def _install_shutdown_signal_handlers() -> None:
             _mc_log(f"could not register SIGINT handler: {e}", "warn")
 
 
+# ── Close-to-stop: closing the terminal STOPS the agent (task b6da0d54, Samuel) ─
+# DISTINCT from the graceful SIGTERM/SIGINT handler above. This fires on a real
+# console CLOSE (window/tab) and flips desired_state->stopped so hostd does NOT
+# respawn it (hostd respawns ONLY desired_state='running'). A genuine CRASH never
+# runs this (process is gone before the handler) -> desired_state stays 'running'
+# -> hostd crash-respawn is PRESERVED. ESC is NOT a close (the window stays open),
+# so it never triggers this. "al cerrar la terminal el agente se debe parar."
+_WIN_CTRL_HANDLER_REF = None  # keep the WINFUNCTYPE callback alive (GC guard)
+
+
+def _flip_desired_state_stopped(timeout_s: float = 3.0) -> None:
+    """Best-effort flip THIS agent's desired_state->stopped via mc_set_desired_state
+    (api_key self-scoped to the calling agent). Fast — Windows CTRL_CLOSE allows ~5s
+    before the OS force-kills, so we time-box the RPC and never block exit."""
+    done = _threading.Event()
+
+    def _do():
+        try:
+            ak = _get_api_key()
+            if ak:
+                be.sb_rpc("mc_set_desired_state", {"p_api_key": ak, "p_state": "stopped"})
+        except Exception:
+            pass
+        done.set()
+
+    try:
+        _threading.Thread(target=_do, daemon=True, name="meshcode-close-set-stopped").start()
+        done.wait(timeout=timeout_s)
+    except Exception:
+        try:
+            ak = _get_api_key()
+            if ak:
+                be.sb_rpc("mc_set_desired_state", {"p_api_key": ak, "p_state": "stopped"})
+        except Exception:
+            pass
+
+
+def _close_to_stop_handler(signum=None, frame=None):  # pragma: no cover - signal handler
+    """Terminal CLOSE -> stop this agent (no respawn). See the block comment above."""
+    try:
+        sys.stderr.write(
+            f"[meshcode-mcp] terminal close (sig={signum}) — desired_state->stopped + release lease\n")
+        sys.stderr.flush()
+    except Exception:
+        pass
+    try:
+        _flip_desired_state_stopped(timeout_s=3.0)
+    except Exception:
+        pass
+    try:
+        _release_lease_synchronous(timeout_s=1.0)
+    except Exception:
+        pass
+    os._exit(0)
+
+
+def _install_close_to_stop_handlers() -> None:
+    """Register console-CLOSE handlers so closing the terminal STOPS the agent (b6da0d54).
+
+    Windows: SetConsoleCtrlHandler for CTRL_CLOSE/LOGOFF/SHUTDOWN — ALWAYS ON (a window
+    close is never an ESC; reliably distinct). This is the prod fix (prod = Windows).
+
+    POSIX: SIGHUP->stop is GATED behind MESHCODE_CLOSE_STOP_SIGHUP=1 (default OFF). The
+    run_server._diag_ignore deliberately IGNORES SIGHUP for ESC/session-restructure
+    survival; reversing it unconditionally risks a false-stop on a transient SIGHUP.
+    Enable only once verified that Claude ESC does not emit SIGHUP to this process.
+    Never touches SIGINT (ESC) or SIGTERM (handled by the opt-in graceful handler)."""
+    if sys.platform == "win32":
+        try:
+            import ctypes
+            from ctypes import wintypes
+            global _WIN_CTRL_HANDLER_REF
+            _HANDLER = ctypes.WINFUNCTYPE(wintypes.BOOL, wintypes.DWORD)
+            CTRL_CLOSE_EVENT, CTRL_LOGOFF_EVENT, CTRL_SHUTDOWN_EVENT = 2, 5, 6
+
+            def _win_ctrl(ctrl_type):
+                if ctrl_type in (CTRL_CLOSE_EVENT, CTRL_LOGOFF_EVENT, CTRL_SHUTDOWN_EVENT):
+                    _close_to_stop_handler(signum=f"win_ctrl:{ctrl_type}")
+                    return True
+                return False  # CTRL_C / CTRL_BREAK -> default handler (not our concern)
+
+            _WIN_CTRL_HANDLER_REF = _HANDLER(_win_ctrl)
+            if ctypes.windll.kernel32.SetConsoleCtrlHandler(_WIN_CTRL_HANDLER_REF, True):
+                _mc_log("registered Windows CTRL_CLOSE close=stop handler (b6da0d54)")
+            else:
+                _mc_log("SetConsoleCtrlHandler(close) returned 0", "warn")
+        except Exception as e:
+            _mc_log(f"could not register Windows close handler: {e}", "warn")
+    else:
+        if os.environ.get("MESHCODE_CLOSE_STOP_SIGHUP", "").lower() in ("1", "true", "yes"):
+            import signal as _sig_mod
+            try:
+                _sig_mod.signal(_sig_mod.SIGHUP, _close_to_stop_handler)
+                _mc_log("registered SIGHUP close=stop handler (MESHCODE_CLOSE_STOP_SIGHUP=1, b6da0d54)")
+            except (ValueError, OSError) as e:
+                _mc_log(f"could not register SIGHUP handler: {e}", "warn")
+        # else: posix SIGHUP stays as run_server._diag_ignore (ESC-survival default)
+
+
 # ── Crash logging + graceful shutdown ──────────────────────────
 _SHUTDOWN_LOGGED = False
 
@@ -2645,6 +2744,14 @@ async def lifespan(_app):
     except Exception as _sig_e:
         log.debug(f"shutdown signal handler install failed: {_sig_e}")
 
+    # Close-to-stop (task b6da0d54): closing the terminal flips desired_state->stopped
+    # so hostd does not respawn (Samuel: 'al cerrar la terminal el agente se debe parar').
+    # Windows CTRL_CLOSE always-on; posix SIGHUP gated (default OFF) — see the fn docstring.
+    try:
+        _install_close_to_stop_handlers()
+    except Exception as _close_e:
+        log.debug(f"close-to-stop handler install failed: {_close_e}")
+
     log.info(f"lifespan started — Realtime + heartbeat thread + orphan watchdog active for {AGENT_NAME}")
     # Enable session recording in backend.py (hot-reloadable)
     try:

{meshcode-2.11.110 → meshcode-2.11.111rc1}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.110 → meshcode-2.11.111rc1}/pyproject.toml

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