meshcode 2.11.86__tar.gz → 2.11.88__tar.gz

{meshcode-2.11.86 → meshcode-2.11.88}/PKG-INFO

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

{meshcode-2.11.86 → meshcode-2.11.88}/meshcode/__init__.py

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

{meshcode-2.11.86 → meshcode-2.11.88}/meshcode/_session_handoff_template.py

@@ -113,6 +113,54 @@ def _extract_tail(transcript_path: str):
     return rows[-MAX_TURNS:]
 
 
+def _request_recycle_if_marked(project_dir) -> None:
+    """CTX-CLOSE-RELAUNCH (task 400fc536): commander-tier sessions ask the
+    server to recycle (close+relaunch fresh) at the next task-edge, right after
+    the handoff is snapshotted. Gated by the scaffold-baked
+    .claude/meshcode_hook_ctx.json recycle_on_compact flag (commander-only v1).
+
+    Best-effort in every dimension: missing marker/flag, missing creds, import
+    failure, network error -> silently skip. handoff.json is already written, so
+    a context-recycle still relaunches WITH context; and the actual exit is the
+    server's call (mc_consume_recycle at a task boundary), never this hook.
+    """
+    try:
+        ctx_path = project_dir / ".claude" / "meshcode_hook_ctx.json"
+        if not ctx_path.exists():
+            return
+        if not json.loads(ctx_path.read_text(encoding="utf-8")).get("recycle_on_compact"):
+            return  # non-commander -> in-place autocompact, no recycle
+        mcp = json.loads((project_dir / ".mcp.json").read_text(encoding="utf-8"))
+        env = (next(iter((mcp.get("mcpServers") or {}).values()), {}) or {}).get("env", {}) or {}
+        url = env.get("SUPABASE_URL"); key = env.get("SUPABASE_KEY")
+        pid = env.get("MESHCODE_PROJECT_ID"); agent = env.get("MESHCODE_AGENT")
+        if not (url and key and pid and agent):
+            return
+        api_key = os.environ.get("MESHCODE_API_KEY")
+        if not api_key:
+            try:
+                import importlib
+                api_key = importlib.import_module("meshcode.secrets").get_api_key(
+                    profile=env.get("MESHCODE_KEYCHAIN_PROFILE") or "default")
+            except Exception:
+                api_key = None
+        if not api_key:
+            return
+        import urllib.request as _u
+        body = json.dumps({
+            "p_api_key": api_key, "p_project_id": pid,
+            "p_agent_name": agent, "p_allow_busy": True,  # flag-now; exit deferred to wait-loop
+        }).encode("utf-8")
+        req = _u.Request(
+            url.rstrip("/") + "/rest/v1/rpc/mc_request_recycle",
+            data=body, method="POST",
+            headers={"apikey": key, "Authorization": "Bearer " + key,
+                     "Content-Type": "application/json"})
+        _u.urlopen(req, timeout=5).read()  # best-effort; ignore result per backend contract
+    except Exception as e:  # noqa: BLE001 — never block compaction
+        sys.stderr.write(f"[session_handoff_write] recycle-request skipped: {e}\\n")
+
+
 def main() -> int:
     try:
         raw = sys.stdin.read()
@@ -137,6 +185,9 @@ def main() -> int:
         tmp.replace(d / "handoff.json")
     except OSError as e:
         sys.stderr.write(f"[session_handoff_write] skipped: {e}\\n")
+    # CTX-CLOSE-RELAUNCH (task 400fc536): now that the thread is snapshotted,
+    # commander-tier sessions ask the server to recycle at the next task-edge.
+    _request_recycle_if_marked(_project_dir())
     return 0
 
 

{meshcode-2.11.86 → meshcode-2.11.88}/meshcode/hostd.py

@@ -45,6 +45,65 @@ import uuid
 from pathlib import Path
 from typing import Optional
 
+# COMMANDER-LIFECYCLE-ALWAYS-WORKS (task ca947d7f): the version of the code THIS hostd
+# process is executing, captured at import. A long-running hostd keeps this in memory, so a
+# bg pip update (new SDK) does NOT land daemon-side fixes (e.g. the Stop kill sweep _do_stops,
+# task 35bee961) until the PROCESS restarts — which is why Samuel's qa sat 'stopping' for ~1h.
+# We compare this against the on-disk installed version each sweep and self-reexec on drift.
+try:
+    from meshcode import __version__ as _RUNNING_VERSION
+except Exception:
+    _RUNNING_VERSION = "0.0.0"
+_LAST_UPDATE_KICK_MONO = 0.0
+
+
+def _maybe_self_restart_on_version_drift() -> None:
+    """Keep a running hostd CURRENT so Stop/launch always work (task ca947d7f).
+
+    (a) periodically kicks the detached, TTL-guarded bg updater so even a host with no
+        agent launches still pulls new wheels onto disk;
+    (b) when the ON-DISK installed version is newer than the code we're running, os.execv-
+        restarts at this safe sweep boundary (no spawn in flight; hostd_state.json incl.
+        headless_pids is persisted and survives the re-exec, so in-flight stop targets aren't
+        lost). After re-exec, running == on-disk -> no re-exec loop.
+    Opt out with MESHCODE_HOSTD_NO_AUTORESTART=1.
+    """
+    global _LAST_UPDATE_KICK_MONO
+    if os.environ.get("MESHCODE_HOSTD_NO_AUTORESTART", "").lower() in ("1", "true", "yes"):
+        return
+    now = time.monotonic()
+    if now - _LAST_UPDATE_KICK_MONO >= 1800:  # at most every 30min
+        _LAST_UPDATE_KICK_MONO = now
+        try:
+            from meshcode import self_update as _su
+            _su.check_and_maybe_update()  # non-blocking, detached, TTL-guarded internally
+        except Exception:
+            pass
+    try:
+        import importlib.metadata as _ilmd
+        ondisk = _ilmd.version("meshcode")  # reads dist-info METADATA on disk (pip-updated)
+    except Exception:
+        return
+    try:
+        from meshcode import self_update as _su
+        newer = _su._is_newer(ondisk, _RUNNING_VERSION)
+    except Exception:
+        def _vt(v):
+            return tuple(int(x) for x in v.split(".") if x.isdigit())
+        try:
+            newer = _vt(ondisk) > _vt(_RUNNING_VERSION)
+        except Exception:
+            newer = False
+    if not newer:
+        return
+    _log(f"VERSION DRIFT: running {_RUNNING_VERSION}, on-disk {ondisk} -> self-reexec to load "
+         f"new code (Stop kill sweep + daemon fixes). headless_pids persisted; KeepAlive re-attaches.")
+    try:
+        os.execv(sys.executable, [sys.executable, "-m", "meshcode"] + sys.argv[1:])
+    except Exception as e:
+        _log(f"WARN: self-reexec failed ({e}); exiting so the supervisor restarts us")
+        os._exit(0)
+
 STATE_DIR = Path.home() / ".meshcode"
 HOST_ID_PATH = STATE_DIR / "host_id"
 LOG_PATH = STATE_DIR / "hostd.log"
@@ -980,6 +1039,10 @@ def cmd_hostd(args: list) -> int:
                             _rpc("mc_host_heartbeat", {"p_api_key": api_key, "p_host_id": host_id})
                         except Exception:
                             pass
+                        # ca947d7f: keep this daemon CURRENT — if a newer SDK is on disk,
+                        # re-exec NOW (before doing work) so Stop's kill sweep + launch fixes
+                        # always run on a stale-running host without manual intervention.
+                        _maybe_self_restart_on_version_drift()
                         relaunched = _do_respawns(api_key, host_id)
                         recycled = _do_recycles(api_key, host_id)
                         ver_recycled = _do_version_recycles(api_key, host_id)

{meshcode-2.11.86 → meshcode-2.11.88}/meshcode/setup_clients.py

@@ -288,6 +288,49 @@ def _stop_hook_command() -> str:
     return _hook_command("stay_on_loop.py")
 
 
+# Mirror of server.py _LEADER_KEYWORDS / _is_leader_agent — the canonical
+# agent-side commander/leader signal. Kept in sync intentionally (small, stable).
+_LEADER_KEYWORDS = (
+    'commander', 'lead', 'orchestrat', 'coordinator', 'coordinat',
+    'coordinad', 'jefe', 'líder', 'lider', 'director', 'manager',
+    'chief', 'captain', 'boss', 'head agent',
+)
+
+
+def _is_commander_role(name: str, role: str = "") -> bool:
+    """True if this agent is commander/leader tier (name+role keyword match).
+
+    CTX-CLOSE-RELAUNCH (task 400fc536): the PreCompact handoff hook self-requests
+    a context-recycle ONLY for commander-tier sessions (v1 = commander-only).
+    The hook subprocess cannot import server.py's _is_leader_agent (its module
+    globals aren't set there), so we BAKE this decision into the workspace at
+    scaffold time (commander directive) using the SAME heuristic the SDK already
+    uses everywhere for leader detection. This is a client-side BEHAVIOUR gate,
+    not authorization — the server's owner check in mc_request_recycle is the
+    real security boundary — so the name/role heuristic is safe here.
+    """
+    hay = ((name or "") + " " + (role or "")).lower()
+    return any(k in hay for k in _LEADER_KEYWORDS)
+
+
+def _write_hook_ctx_marker(ws: Path, is_commander: bool, agent: str = "", project: str = "") -> None:
+    """Write .claude/meshcode_hook_ctx.json — the scaffold-baked signal the
+    PreCompact handoff hook reads to decide whether to self-request a
+    context-recycle (CTX-CLOSE-RELAUNCH). Best-effort."""
+    try:
+        (ws / ".claude").mkdir(parents=True, exist_ok=True)
+        (ws / ".claude" / "meshcode_hook_ctx.json").write_text(
+            json.dumps({
+                "recycle_on_compact": bool(is_commander),
+                "agent": agent,
+                "project": project,
+            }, indent=2) + "\n",
+            encoding="utf-8",
+        )
+    except Exception as _e:  # noqa: BLE001 — never block scaffold on this marker
+        print(f"[meshcode] WARNING: could not write hook ctx marker: {_e}", file=sys.stderr)
+
+
 # The meshcode hooks (event -> hook-script filename). Each is matched in
 # settings.json by its script filename so the heal touches ONLY meshcode's own
 # hooks and never a user-added hook on the same event.
@@ -1487,6 +1530,10 @@ Call `meshcode_wait` now.
             except OSError:
                 pass
         (ws / ".claude" / "settings.json").write_text(settings_body, encoding="utf-8")
+        # CTX-CLOSE-RELAUNCH (task 400fc536): bake the commander-tier signal the
+        # PreCompact handoff hook reads to decide whether to self-request a
+        # context-recycle (commander-only v1).
+        _write_hook_ctx_marker(ws, _is_commander_role(agent, role), agent=agent, project=project)
     except Exception as _e:
         print(f"[meshcode] WARNING: could not write /meshcode-wait command + hooks: {_e}", file=sys.stderr)
 
@@ -1749,7 +1796,25 @@ def patch_hooks(dry_run: bool = False) -> int:
         except Exception as e:  # noqa: BLE001 — never let one ws abort the sweep
             settings_changed, settings_note = False, f"settings heal failed: {e}"
 
-        record = f"{ws.name} ({body_note}; {settings_note})"
+        # CTX-CLOSE-RELAUNCH (task 400fc536): backfill the commander-tier marker
+        # the PreCompact hook reads. Recompute is_commander from the workspace's
+        # baked .mcp.json (MESHCODE_AGENT + MESHCODE_ROLE) so existing commanders
+        # get the recycle trigger without a full re-scaffold.
+        marker_note = "marker skipped"
+        if not dry_run:
+            try:
+                mcp = json.loads((ws / ".mcp.json").read_text(encoding="utf-8"))
+                env = (next(iter((mcp.get("mcpServers") or {}).values()), {}) or {}).get("env", {}) or {}
+                _agent = env.get("MESHCODE_AGENT") or ws.name
+                _role = env.get("MESHCODE_ROLE") or ""
+                _write_hook_ctx_marker(ws, _is_commander_role(_agent, _role), agent=_agent, project=env.get("MESHCODE_PROJECT") or "")
+                marker_note = "marker written"
+            except Exception as e:  # noqa: BLE001
+                marker_note = f"marker skipped ({e})"
+        else:
+            marker_note = "marker would write"
+
+        record = f"{ws.name} ({body_note}; {settings_note}; {marker_note})"
         (patched if (body_changed or settings_changed) else skipped).append(record)
 
     verb = "would patch" if dry_run else "patched"

{meshcode-2.11.86 → meshcode-2.11.88}/meshcode.egg-info/PKG-INFO

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

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

@@ -0,0 +1,89 @@
+README.md
+pyproject.toml
+meshcode/__init__.py
+meshcode/__main__.py
+meshcode/_session_handoff_template.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.88/meshcode.egg-info/top_level.txt

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

{meshcode-2.11.86 → meshcode-2.11.88}/pyproject.toml

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