meshcode 2.11.85__tar.gz → 2.11.87__tar.gz

{meshcode-2.11.85 → meshcode-2.11.87}/PKG-INFO

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

{meshcode-2.11.85 → meshcode-2.11.87}/meshcode/__init__.py

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

{meshcode-2.11.85 → meshcode-2.11.87}/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.85 → meshcode-2.11.87}/meshcode/meshcode_mcp/server.py

@@ -6041,6 +6041,55 @@ def meshcode_add_agent(name: str, role: str = "", autonomous: bool = False) -> D
     return result or {"error": "failed to add agent"}
 
 
+@mcp.tool()
+@with_working_status
+def meshcode_agent_launch(name: str, headless: bool = False) -> Dict[str, Any]:
+    """Launch (or restart) another agent in YOUR meshwork — open it on command
+    or by your own judgment (e.g. spin an agent up when task load rises).
+
+    COMMANDER-AGENT-LIFECYCLE (task 11feedd1). Sets desired_state=running so the
+    host daemon spawns the agent; visible by default, headless opt-in. Only the
+    project's commander agent (or the human owner) may power other agents, and
+    only within their own meshwork — enforced server-side by
+    mc_agent_power_as_agent (api_key identity + scope_meshwork_id check).
+
+    Args:
+        name: target agent name in your meshwork.
+        headless: True = run in the background with no visible window;
+            default False = visible focused window.
+    """
+    return be.sb_rpc("mc_agent_power_as_agent", {
+        "p_api_key":    _get_api_key(),
+        "p_project_id": _PROJECT_ID,
+        "p_agent":      name,
+        "p_state":      "running",
+        "p_headless":   bool(headless),
+    })
+
+
+@mcp.tool()
+@with_working_status
+def meshcode_agent_stop(name: str) -> Dict[str, Any]:
+    """Stop another agent in YOUR meshwork — close it on command or by your own
+    judgment (e.g. spin an idle agent down).
+
+    COMMANDER-AGENT-LIFECYCLE (task 11feedd1). Sets desired_state=stopped; the
+    host daemon kills the process via the stop backstop (task 94603f18), so a
+    headless agent with no window to close is actually terminated. Commander
+    agent (or human owner) only, scoped to your own meshwork — enforced
+    server-side by mc_agent_power_as_agent.
+
+    Args:
+        name: target agent name in your meshwork.
+    """
+    return be.sb_rpc("mc_agent_power_as_agent", {
+        "p_api_key":    _get_api_key(),
+        "p_project_id": _PROJECT_ID,
+        "p_agent":      name,
+        "p_state":      "stopped",
+    })
+
+
 @mcp.tool()
 @with_working_status
 def meshcode_set_meshwork_autonomous_default(enabled: bool) -> Dict[str, Any]:

{meshcode-2.11.85 → meshcode-2.11.87}/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.85 → meshcode-2.11.87}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.85 → meshcode-2.11.87}/meshcode.egg-info/SOURCES.txt

@@ -6,7 +6,6 @@ meshcode/_session_handoff_template.py
 meshcode/_stop_hook_template.py
 meshcode/ascii_art.py
 meshcode/atomic_push.py
-meshcode/claude_update 2.py
 meshcode/claude_update.py
 meshcode/cli.py
 meshcode/comms_v4.py
@@ -16,7 +15,6 @@ meshcode/date_parse.py
 meshcode/doctor.py
 meshcode/error_hints.py
 meshcode/exceptions.py
-meshcode/hostd 2.py
 meshcode/hostd.py
 meshcode/invites.py
 meshcode/launcher.py
@@ -31,7 +29,6 @@ meshcode/secrets.py
 meshcode/self_update.py
 meshcode/setup_clients.py
 meshcode/supervisor.py
-meshcode/up 2.py
 meshcode/up.py
 meshcode/upload.py
 meshcode-backend-wt/comms_v4.py

{meshcode-2.11.85 → meshcode-2.11.87}/pyproject.toml

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

meshcode-2.11.85/meshcode/claude_update 2.py

@@ -1,258 +0,0 @@
-"""Synchronous Claude Code CLI auto-update for `meshcode run`.
-
-Companion to self_update.py (which handles the `meshcode` Python package).
-When `meshcode run` launches an agent, this module probes the npm registry
-for the latest @anthropic-ai/claude-code release and runs `npm install -g`
-inline if the installed version is older. The launch BLOCKS until the
-upgrade finishes (or times out).
-
-This is intentional: Samuel's requirement is "siempre arrancar con la
-ultima version". The two-launch async model in self_update.py cannot
-satisfy that — it always uses the old binary on launch N. The blocking
-model trades ~5-30s extra latency on launches where an upgrade is
-available for the guarantee that the freshly-spawned editor uses the
-newest CLI.
-
-Skip conditions (any one → no-op):
-  - MESHCODE_NO_UPDATE=1 / --no-update on argv
-  - Inside an existing Claude Code session (CLAUDECODE=1)
-  - User pinned a specific version via env / prefs (let _resolve_pinned_claude handle it)
-  - Editor is not `claude` (cursor / code / codex / windsurf)
-  - npm not in PATH
-  - Network unreachable / npm registry down
-  - Already at latest version
-
-Failures are best-effort: any error prints a single WARN line and lets
-launch continue with whatever version is installed.
-"""
-from __future__ import annotations
-
-import json
-import os
-import re
-import shutil
-import subprocess
-import sys
-import time
-from pathlib import Path
-from typing import Optional, Tuple
-
-NPM_PKG = "@anthropic-ai/claude-code"
-NPM_REGISTRY_URL = f"https://registry.npmjs.org/{NPM_PKG}/latest"
-NETWORK_TIMEOUT_SEC = 2.5
-INSTALL_TIMEOUT_SEC = 90  # npm i -g can be slow on cold-cache machines
-
-STATE_DIR = Path.home() / ".meshcode"
-LOG_PATH = STATE_DIR / "claude_update.log"
-
-
-# ============================================================
-# Skip-condition helpers
-# ============================================================
-
-def _is_claude_session() -> bool:
-    """True if we're being called from inside an existing Claude Code session.
-
-    Replacing the npm binary while claude is running is unsafe and pointless
-    — the running claude won't pick up the new code anyway.
-    """
-    return os.environ.get("CLAUDECODE") == "1" or bool(os.environ.get("CLAUDE_CODE_SESSION"))
-
-
-def _update_disabled() -> bool:
-    # task 399d7b51 FIX A (unify): honor MESHCODE_NO_AUTO_UPDATE too. hostd launcher / run_agent /
-    # schtasks set that var to disable ALL launch-time auto-update; previously only the meshcode-pip
-    # path checked MESHCODE_NO_UPDATE, so the claude-CLI blocking update still fired (extra hang).
-    if os.environ.get("MESHCODE_NO_UPDATE") == "1":
-        return True
-    if os.environ.get("MESHCODE_NO_AUTO_UPDATE") == "1":
-        return True
-    if "--no-update" in sys.argv or "--no-auto-update" in sys.argv:
-        return True
-    return False
-
-
-def _resolve_user_pin() -> Optional[str]:
-    """Return a specific version pin if set; None if 'latest' / unset.
-
-    Sources checked (first non-empty wins):
-      1. MESHCODE_CLAUDE_VERSION env var
-      2. prefs['claude_version']
-
-    Note: 'latest' / 'none' / 'skip' values are treated as "no pin" — the
-    user wants whatever is current. We do NOT consult the global admin
-    config from mc_global_config here; if an admin pins a specific
-    version, _resolve_pinned_claude in run_agent.py will route through
-    npx regardless of what's installed locally.
-    """
-    pinned = (os.environ.get("MESHCODE_CLAUDE_VERSION") or "").strip()
-    if not pinned:
-        try:
-            from .preferences import load_prefs
-            pinned = (load_prefs().get("claude_version") or "").strip()
-        except Exception:
-            pinned = ""
-    if not pinned:
-        return None
-    if pinned.lower() in ("latest", "none", "skip"):
-        return None
-    return pinned
-
-
-# ============================================================
-# Version probes
-# ============================================================
-
-def _get_installed_version(editor_cmd: str) -> Optional[str]:
-    """Run `<editor_cmd> --version` and pull the first semver from stdout."""
-    try:
-        use_shell = sys.platform == "win32" and editor_cmd.lower().endswith((".cmd", ".bat"))
-        r = subprocess.run(
-            [editor_cmd, "--version"],
-            capture_output=True, text=True, timeout=10,
-            shell=use_shell,
-        )
-        m = re.search(r"\d+\.\d+\.\d+", r.stdout or "")
-        return m.group(0) if m else None
-    except Exception:
-        return None
-
-
-def _fetch_npm_latest() -> Optional[str]:
-    """GET https://registry.npmjs.org/<pkg>/latest — returns the JSON manifest
-    of the version tagged `latest`, with a `version` field.
-
-    Do NOT send the `application/vnd.npm.install-v1+json` Accept header
-    here: the slim-manifest content type is only valid on the package
-    ROOT (/<pkg>), not on /<pkg>/<tag>. Sending it on the tag endpoint
-    returns HTTP 406. Default Accept (*/*) gets the canonical JSON.
-    """
-    try:
-        import urllib.request
-        req = urllib.request.Request(NPM_REGISTRY_URL)
-        with urllib.request.urlopen(req, timeout=NETWORK_TIMEOUT_SEC) as resp:
-            data = json.loads(resp.read().decode("utf-8"))
-        v = data.get("version")
-        if isinstance(v, str):
-            return v
-    except Exception:
-        pass
-    return None
-
-
-def _version_tuple(v: str) -> Tuple[int, ...]:
-    parts = []
-    for p in v.split("."):
-        digits = "".join(c for c in p if c.isdigit())
-        parts.append(int(digits) if digits else 0)
-    return tuple(parts)
-
-
-def _is_newer(remote: str, local: str) -> bool:
-    try:
-        return _version_tuple(remote) > _version_tuple(local)
-    except Exception:
-        return False
-
-
-# ============================================================
-# Editor-stem detection (only act when editor is claude)
-# ============================================================
-
-def _editor_is_claude(editor_cmd: str) -> bool:
-    name = os.path.basename(editor_cmd).lower()
-    if sys.platform == "win32":
-        name = name.rsplit(".", 1)[0] if "." in name else name
-    return name == "claude"
-
-
-# ============================================================
-# Public entrypoint
-# ============================================================
-
-def check_and_maybe_update_claude_blocking(
-    editor_cmd: str,
-    verbose: bool = True,
-    timeout_sec: int = INSTALL_TIMEOUT_SEC,
-) -> Optional[str]:
-    """Probe npm + foreground-install latest claude if newer.
-
-    Returns the new version on successful upgrade, None otherwise.
-    Never raises — all errors are swallowed and logged via WARN line.
-    """
-    if _update_disabled():
-        return None
-    if _is_claude_session():
-        return None
-    if _resolve_user_pin():
-        return None
-    if not _editor_is_claude(editor_cmd):
-        return None
-
-    current = _get_installed_version(editor_cmd)
-    latest = _fetch_npm_latest()
-    if not current:
-        if verbose:
-            print(f"[meshcode] (Could not read claude --version; skipping auto-update)", file=sys.stderr)
-        return None
-    if not latest:
-        if verbose:
-            print(f"[meshcode] (Could not reach npm registry; staying on claude {current})", file=sys.stderr)
-        return None
-    if not _is_newer(latest, current):
-        if verbose:
-            print(f"[meshcode] claude {current} (already latest)", file=sys.stderr)
-        return None
-
-    npm = shutil.which("npm")
-    if not npm:
-        if verbose:
-            print(
-                f"[meshcode] WARN: claude {current} < {latest} on npm, but `npm` not in PATH; "
-                f"continuing on {current}",
-                file=sys.stderr,
-            )
-        return None
-
-    if verbose:
-        print(
-            f"[meshcode] Upgrading claude {current} -> {latest} (blocking, can take ~30s)...",
-            file=sys.stderr,
-        )
-
-    cmd = [npm, "install", "-g", f"{NPM_PKG}@{latest}"]
-    try:
-        STATE_DIR.mkdir(parents=True, exist_ok=True)
-        with open(LOG_PATH, "ab") as logf:
-            logf.write(
-                f"\n=== {time.strftime('%Y-%m-%d %H:%M:%S')} blocking "
-                f"npm i -g {NPM_PKG}@{latest} ===\n".encode()
-            )
-            logf.flush()
-            proc = subprocess.run(cmd, stdout=logf, stderr=logf, timeout=timeout_sec)
-        if proc.returncode == 0:
-            if verbose:
-                print(f"[meshcode]   claude upgraded to {latest}", file=sys.stderr)
-            return latest
-        if verbose:
-            print(
-                f"[meshcode] WARN: npm install exit {proc.returncode}; "
-                f"continuing on {current} (log: {LOG_PATH})",
-                file=sys.stderr,
-            )
-        return None
-    except subprocess.TimeoutExpired:
-        if verbose:
-            print(
-                f"[meshcode] WARN: npm install timed out after {timeout_sec}s; "
-                f"continuing on {current}",
-                file=sys.stderr,
-            )
-        return None
-    except Exception as e:
-        if verbose:
-            print(
-                f"[meshcode] WARN: npm install failed: {e}; continuing on {current}",
-                file=sys.stderr,
-            )
-        return None