meshcode 2.11.73__tar.gz → 2.11.75__tar.gz

{meshcode-2.11.73 → meshcode-2.11.75}/PKG-INFO

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

{meshcode-2.11.73 → meshcode-2.11.75}/meshcode/__init__.py

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

{meshcode-2.11.73 → meshcode-2.11.75}/meshcode/claude_update.py

@@ -60,9 +60,14 @@ def _is_claude_session() -> bool:
 
 
 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 "--no-update" in sys.argv:
+    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
 

{meshcode-2.11.73 → meshcode-2.11.75}/meshcode/comms_v4.py

@@ -2388,6 +2388,16 @@ def login(api_key):
     backend = secrets_mod.keyring_status().get("backend", "?")
     print(f"[meshcode] Authenticated as {result['display_name']} ({result['email']})")
     print(f"[meshcode]   API key stored in OS keychain ({backend})")
+
+    # ZERO-SETUP (task f12b9d36): auto-bootstrap hostd so Launch works with no manual
+    # `meshcode hostd install`. Idempotent + cross-platform + best-effort (never breaks login).
+    try:
+        import importlib as _il
+        _hd = _il.import_module("meshcode.hostd")
+        _hd._hostd_bootstrap(verbose=True)
+    except Exception:
+        pass
+
     return True
 
 

{meshcode-2.11.73 → meshcode-2.11.75}/meshcode/hostd.py

@@ -35,6 +35,7 @@ from __future__ import annotations
 import json
 import os
 import shlex
+import shutil
 import subprocess
 import sys
 import time
@@ -47,8 +48,18 @@ STATE_DIR = Path.home() / ".meshcode"
 HOST_ID_PATH = STATE_DIR / "host_id"
 LOG_PATH = STATE_DIR / "hostd.log"
 
-POLL_INTERVAL_SEC = 45
-STALE_SECONDS = 150          # heartbeat liveness cutoff (QA #3)
+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.
+    try:
+        v = int(os.environ.get("MESHCODE_HOSTD_POLL_SEC", "10"))
+    except Exception:
+        v = 10
+    return max(3, v)
+
+
+POLL_INTERVAL_SEC = _env_poll_interval()  # default 10s (was 45); env MESHCODE_HOSTD_POLL_SEC, floor 3
+STALE_SECONDS = 150          # heartbeat liveness cutoff (QA #3) — do NOT lower (false respawns / boot-storm)
 RESPAWN_TIMEOUT_SEC = 30
 # statuses that mean "actively working" → never recycle mid-task
 BUSY_STATUSES = {"working", "online", "busy"}
@@ -204,6 +215,7 @@ def _spawn_agent(project: str, agent: str, headless: bool = False) -> bool:
         env = {k: v for k, v in os.environ.items()
                if k not in ("CLAUDECODE", "CLAUDE_CODE_SESSION")}
         env["MESHCODE_NO_AUTO_UPDATE"] = "1"
+        env["MESHCODE_NO_UPDATE"] = "1"  # belt-and-suspenders: var honored pre-2.11.74 (no launch-hang)
         log_dir = STATE_DIR / "logs"
         try:
             log_dir.mkdir(parents=True, exist_ok=True)
@@ -257,10 +269,11 @@ def _spawn_agent(project: str, agent: str, headless: bool = False) -> bool:
     # on ';' -> file-not-found. Layered ON TOP of the 2.11.72 headless-flags fix (visible branch only).
     if sys.platform == "win32":
         cmd = (f'set "CLAUDECODE=" & set "CLAUDE_CODE_SESSION=" & '
-               f'set "MESHCODE_NO_AUTO_UPDATE=1" & "{bin_}" run "{target}"')
+               f'set "MESHCODE_NO_AUTO_UPDATE=1" & set "MESHCODE_NO_UPDATE=1" & '
+               f'"{bin_}" run "{target}"')
     else:
         cmd = (f"unset CLAUDECODE CLAUDE_CODE_SESSION; export MESHCODE_NO_AUTO_UPDATE=1; "
-               f"exec {shlex.quote(bin_)} run {shlex.quote(target)}")
+               f"export MESHCODE_NO_UPDATE=1; exec {shlex.quote(bin_)} run {shlex.quote(target)}")
     try:
         from meshcode import protocol_handler as _ph
         ok, info = _ph._spawn_terminal(cmd)
@@ -447,7 +460,9 @@ def _hostd_install_windows() -> int:
     launch_cmd = STATE_DIR / "hostd-launch.cmd"
     launch_cmd.write_text(
         "@echo off\r\n"
-        'set "MESHCODE_NO_AUTO_UPDATE=1"\r\n'
+        'set "MESHCODE_NO_UPDATE=1"\r\n'        # var honored pre-2.11.74 (belt-and-suspenders)
+        'set "MESHCODE_NO_AUTO_UPDATE=1"\r\n'   # unified var (honored 2.11.74+)
+        'set "MESHCODE_HOSTD_POLL_SEC=10"\r\n'  # faster click->spawn (default 10s, floor 3)
         f'"{mc}" hostd run\r\n',
         encoding="utf-8",
     )
@@ -471,12 +486,64 @@ def _hostd_install_windows() -> int:
     return 0
 
 
+_HOSTD_SYSTEMD_UNIT = "meshcode-hostd.service"
+
+
+def _hostd_run_argv() -> list:
+    """Argv that runs `meshcode hostd run`, resolving the installed console script or
+    falling back to `python -m meshcode`."""
+    mc = shutil.which("meshcode")
+    if mc:
+        return [mc, "hostd", "run"]
+    return [sys.executable, "-m", "meshcode", "hostd", "run"]
+
+
+def _hostd_install_linux() -> int:
+    """Linux (task f12b9d36): systemd --user unit (durable, auto-restart, survives logout-login)
+    with nohup fallback when systemd --user isn't usable (no session bus / container)."""
+    (STATE_DIR / "logs").mkdir(parents=True, exist_ok=True)
+    argv = _hostd_run_argv()
+    execstart = " ".join(shlex.quote(a) for a in argv)
+    if shutil.which("systemctl"):
+        unit_dir = Path.home() / ".config" / "systemd" / "user"
+        unit_dir.mkdir(parents=True, exist_ok=True)
+        (unit_dir / _HOSTD_SYSTEMD_UNIT).write_text(
+            "[Unit]\nDescription=MeshCode hostd\nAfter=default.target\n\n"
+            "[Service]\nType=simple\n"
+            "Environment=MESHCODE_NO_UPDATE=1\nEnvironment=MESHCODE_NO_AUTO_UPDATE=1\n"
+            "Environment=MESHCODE_HOSTD_POLL_SEC=10\n"
+            f"ExecStart={execstart}\nRestart=on-failure\nRestartSec=10\n\n"
+            "[Install]\nWantedBy=default.target\n",
+            encoding="utf-8",
+        )
+        subprocess.run(["systemctl", "--user", "daemon-reload"], capture_output=True, text=True)
+        r = subprocess.run(["systemctl", "--user", "enable", "--now", _HOSTD_SYSTEMD_UNIT],
+                           capture_output=True, text=True)
+        if r.returncode == 0:
+            print(f"[hostd] installed systemd --user unit '{_HOSTD_SYSTEMD_UNIT}' (enabled + started)")
+            return 0
+        _log(f"systemd --user enable failed ({r.stderr.strip()}); falling back to nohup")
+    # nohup fallback: starts now (host registers); not reboot-persistent.
+    env = {**os.environ, "MESHCODE_NO_UPDATE": "1", "MESHCODE_NO_AUTO_UPDATE": "1",
+           "MESHCODE_HOSTD_POLL_SEC": "10"}
+    try:
+        logf = open(STATE_DIR / "logs" / "hostd.stdout.log", "ab")
+    except Exception:
+        logf = subprocess.DEVNULL
+    subprocess.Popen(argv, stdout=logf, stderr=subprocess.STDOUT, stdin=subprocess.DEVNULL,
+                     start_new_session=True, env=env)
+    print("[hostd] started via nohup (no systemd --user available; not reboot-persistent)")
+    return 0
+
+
 def _hostd_install() -> int:
     import platform
     if platform.system() == "Windows":
         return _hostd_install_windows()
+    if platform.system() == "Linux":
+        return _hostd_install_linux()
     if platform.system() != "Darwin":
-        print("[hostd] launchd install is macOS only (Linux: use systemd --user; or run `meshcode hostd run` under your own supervisor).", file=sys.stderr)
+        print("[hostd] unsupported platform; run `meshcode hostd run` under your own supervisor.", file=sys.stderr)
         return 2
     plist = _hostd_plist_path()
     plist.parent.mkdir(parents=True, exist_ok=True)
@@ -510,6 +577,48 @@ def _hostd_uninstall() -> int:
     return 0
 
 
+def _hostd_bootstrap(verbose: bool = False) -> bool:
+    """Idempotent auto-install + start of hostd (task f12b9d36) — called from `meshcode login`
+    so onboarding is just `pip install meshcode` + `meshcode login` (no manual `hostd install`).
+    If the OS job already exists, just ensure it's running (don't bounce a live daemon); else
+    install + start. Best-effort: NEVER raises — login must not fail on a bootstrap hiccup."""
+    import platform
+    try:
+        sysname = platform.system()
+        if sysname == "Darwin":
+            if not _hostd_plist_path().exists():
+                _hostd_install()  # writes plist + launchctl load
+            try:
+                uid = str(os.getuid())
+                subprocess.run(["launchctl", "kickstart", f"gui/{uid}/{_HOSTD_PLIST_LABEL}"],
+                               capture_output=True, text=True)  # start if not already running
+            except Exception:
+                pass
+        elif sysname == "Windows":
+            q = subprocess.run(["schtasks", "/Query", "/TN", _HOSTD_TASK_NAME],
+                               capture_output=True, text=True)
+            if q.returncode != 0:
+                _hostd_install_windows()
+            subprocess.run(["schtasks", "/Run", "/TN", _HOSTD_TASK_NAME],
+                           capture_output=True, text=True)  # harmless if already running
+        else:  # Linux + others
+            if shutil.which("systemctl"):
+                act = subprocess.run(["systemctl", "--user", "is-active", _HOSTD_SYSTEMD_UNIT],
+                                     capture_output=True, text=True)
+                if act.stdout.strip() == "active":
+                    return True  # already running — no-op
+            _hostd_install_linux()  # systemd enable --now, or nohup fallback
+        if verbose:
+            print("[meshcode] hostd bootstrapped — Launch is ready (no manual setup needed).")
+        return True
+    except Exception as e:
+        try:
+            _log(f"hostd bootstrap skipped: {e}")
+        except Exception:
+            pass
+        return False
+
+
 def cmd_hostd(args: list) -> int:
     """Entry point for `meshcode hostd ...`."""
     if not args or args[0] in ("-h", "--help"):

{meshcode-2.11.73 → meshcode-2.11.75}/meshcode/self_update.py

@@ -96,14 +96,59 @@ def is_pipx_install() -> bool:
 
 
 def update_disabled() -> bool:
-    """User explicitly opted out for this run / globally."""
+    """User explicitly opted out for this run / globally.
+
+    task 399d7b51 FIX A: honor BOTH var names. The hostd launcher, run_agent, and the 2.11.73
+    Windows schtasks installer all historically set MESHCODE_NO_AUTO_UPDATE (NOT MESHCODE_NO_UPDATE),
+    so the "disable" everyone believed they were applying was a silent NO-OP — every launch still
+    ran the blocking pip update (and hung on Windows WinError 32). Accept both names + flags.
+    """
     if os.environ.get("MESHCODE_NO_UPDATE") == "1":
         return True
-    if "--no-update" in sys.argv:
+    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 _selfheal_pip_turds() -> int:
+    """FIX C (399d7b51): remove ~eshcode / ~~shcode leftovers that pip drops in site-packages when a
+    Windows overwrite of meshcode.exe fails (WinError 32). Best-effort; returns count removed."""
+    import glob
+    removed = 0
+    dirs = set()
+    try:
+        import site
+        for p in (site.getsitepackages() if hasattr(site, "getsitepackages") else []):
+            dirs.add(p)
+        try:
+            dirs.add(site.getusersitepackages())
+        except Exception:
+            pass
+    except Exception:
+        pass
+    try:
+        dirs.add(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+    except Exception:
+        pass
+    for d in dirs:
+        if not d or not os.path.isdir(d):
+            continue
+        for pat in ("~eshcode*", "~~shcode*", "~~eshcode*"):
+            for t in glob.glob(os.path.join(d, pat)):
+                try:
+                    if os.path.isdir(t):
+                        import shutil as _sh
+                        _sh.rmtree(t, ignore_errors=True)
+                    else:
+                        os.remove(t)
+                    removed += 1
+                except Exception:
+                    pass
+    return removed
+
+
 def _version_tuple(v: str) -> Tuple[int, ...]:
     parts = []
     for p in v.split("."):
@@ -401,6 +446,22 @@ def check_and_maybe_update_blocking(verbose: bool = True, timeout_sec: int = 60)
         # Dev mode — never touch the working tree from underneath the user.
         return None
 
+    # FIX B+C (399d7b51): on Windows an inline `pip install -U meshcode` CANNOT overwrite
+    # meshcode.exe while a meshcode process is running (WinError 32) — it has hung ~10s and
+    # FAILED on every Windows launch since April, leaving ~eshcode/~~shcode turds. Do NOT block:
+    # self-heal the turds, then delegate to the NON-blocking staged updater (applies on a future
+    # clean start) and return immediately so the launch goes straight to the editor.
+    if sys.platform == "win32":
+        try:
+            _selfheal_pip_turds()
+        except Exception:
+            pass
+        try:
+            check_and_maybe_update(verbose=verbose)  # non-blocking; never overwrites a live .exe inline
+        except Exception:
+            pass
+        return None
+
     cur = _current_version()
     latest = fetch_latest_version()
     _mark_checked(latest)

{meshcode-2.11.73 → meshcode-2.11.75}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.73 → meshcode-2.11.75}/pyproject.toml

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