meshcode 2.11.82__tar.gz → 2.11.83__tar.gz

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

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

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

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

meshcode-2.11.83/meshcode/claude_update.py

@@ -0,0 +1,258 @@
+"""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

meshcode-2.11.82/meshcode/hostd.py → meshcode-2.11.83/meshcode/hostd 2.py

@@ -811,6 +811,10 @@ def cmd_hostd(args: list) -> int:
         else:
             _log(f"WARN: host registration failed (dashboard may not list this host): {_reg}")
         _log(f"hostd starting — host_id={host_id} interval={POLL_INTERVAL_SEC}s stale={STALE_SECONDS}s")
+        # uptime-since-spawn (core's suggestion): if the daemon dies <2min, the last alive log +
+        # the uptime stamped on the FATAL line reveal the <2min pattern for RC.
+        _spawn_mono = time.monotonic()
+        _last_alive_log = 0.0
         # OUTER resilience (P1): a code exception in the poll loop must NEVER kill the daemon.
         while True:
             try:
@@ -824,17 +828,21 @@ 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)
+                        _up = int(time.monotonic() - _spawn_mono)
                         if relaunched or recycled or ver_recycled:
-                            _log(f"sweep done — {relaunched} respawned, {recycled} recycled, {ver_recycled} version-recycled")
+                            _log(f"sweep done (uptime={_up}s) — {relaunched} respawned, {recycled} recycled, {ver_recycled} version-recycled")
+                        elif time.monotonic() - _last_alive_log >= 60:
+                            _log(f"alive — uptime={_up}s")
+                            _last_alive_log = time.monotonic()
                     except Exception as e:
                         import traceback as _tb
-                        _log(f"WARN: sweep error: {e}\n{_tb.format_exc()}")
+                        _log(f"WARN: sweep error (uptime={int(time.monotonic() - _spawn_mono)}s): {e}\n{_tb.format_exc()}")
                     time.sleep(POLL_INTERVAL_SEC)
             except (KeyboardInterrupt, SystemExit):
                 raise  # honor a real shutdown signal
             except BaseException as e:
                 import traceback as _tb
-                _log(f"FATAL: poll loop crashed (restarting loop in 5s): {e}\n{_tb.format_exc()}")
+                _log(f"FATAL: poll loop crashed (uptime={int(time.monotonic() - _spawn_mono)}s, restarting loop in 5s): {e}\n{_tb.format_exc()}")
                 time.sleep(5)
 
     print(f"[hostd] unknown subcommand: {sub}", file=sys.stderr)