meshcode 2.11.85__tar.gz → 2.11.86__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.11.85
+Version: 2.11.86
 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.86}/meshcode/__init__.py

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.11.85
+Version: 2.11.86
 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.86}/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.86}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "meshcode"
-version = "2.11.85"
+version = "2.11.86"
 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