meshcode 2.11.74__tar.gz → 2.11.76__tar.gz

{meshcode-2.11.74 → meshcode-2.11.76}/PKG-INFO

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

{meshcode-2.11.74 → meshcode-2.11.76}/meshcode/__init__.py

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

{meshcode-2.11.74 → meshcode-2.11.76}/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.74 → meshcode-2.11.76}/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
@@ -211,10 +212,13 @@ def _spawn_agent(project: str, agent: str, headless: bool = False) -> bool:
         # background, NO terminal — UNIVERSAL macOS/Linux/Windows (task c1a6c6a8, mesh-dev specs).
         # Clean env (a stale CLAUDECODE aborts `meshcode run`); keep crash logs in a per-agent logfile
         # (NOT DEVNULL — we want to debug headless agents that die on boot).
+        # task 14782bb4: spawned agents DO auto-update (non-blocking) — strip any inherited
+        # NO_*UPDATE so the agent's launch runs the bg updater (the daemon launcher stays disabled).
+        # No hang: run_agent now uses the NON-blocking updater + we spawn via `python -m meshcode`
+        # (not the .exe shim) so a bg `pip install -U` can replace meshcode.exe on Windows.
         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)
+               if k not in ("CLAUDECODE", "CLAUDE_CODE_SESSION",
+                            "MESHCODE_NO_UPDATE", "MESHCODE_NO_AUTO_UPDATE")}
         log_dir = STATE_DIR / "logs"
         try:
             log_dir.mkdir(parents=True, exist_ok=True)
@@ -235,11 +239,11 @@ def _spawn_agent(project: str, agent: str, headless: bool = False) -> bool:
         }
         if sys.platform == "win32":
             # CREATE_NO_WINDOW (0x08000000) | DETACHED_PROCESS (0x08): no console window, fully
-            # detached from this daemon. Use the console entry-point (meshcode.exe), NEVER pythonw
-            # (it swallows stderr). Ensure venv Scripts + System32 on PATH (Windows PATH cap ~32k).
+            # detached from this daemon. NEVER pythonw (swallows stderr). Ensure venv Scripts +
+            # System32 on PATH (Windows PATH cap ~32k).
             kwargs["creationflags"] = 0x08000000 | 0x00000008
             try:
-                scripts = str(Path(bin_).resolve().parent)
+                scripts = str(Path(sys.executable).resolve().parent)  # venv Scripts dir
             except Exception:
                 scripts = ""
             sysroot = os.environ.get("SystemRoot", r"C:\Windows")
@@ -249,7 +253,9 @@ def _spawn_agent(project: str, agent: str, headless: bool = False) -> bool:
             # POSIX: detach into its own session so it survives the daemon + has no controlling tty.
             kwargs["start_new_session"] = True
         try:
-            subprocess.Popen([bin_, "run", target], **kwargs)
+            # `python -m meshcode` (NOT the meshcode.exe shim) so the .exe isn't held open by the
+            # agent -> a background `pip install -U` can replace it on Windows (task 14782bb4 #4).
+            subprocess.Popen([sys.executable, "-m", "meshcode", "run", target], **kwargs)
             _log(f"spawned {target} HEADLESS (no window, {sys.platform}; log={log_path})")
             return True
         except Exception as e:
@@ -266,13 +272,15 @@ def _spawn_agent(project: str, agent: str, headless: bool = False) -> bool:
     # command PER-PLATFORM (mesh-core FIX1, 0x80070002): cmd.exe uses & (NOT ';'), set "V=" to clear
     # (NOT bash unset/export), double-quotes (NOT shlex POSIX), no exec — else Windows Terminal splits
     # on ';' -> file-not-found. Layered ON TOP of the 2.11.72 headless-flags fix (visible branch only).
+    # task 14782bb4: CLEAR any inherited NO_*UPDATE (so the agent auto-updates non-blocking) and run
+    # via `python -m meshcode` (NOT the .exe shim) so a bg `pip install -U` can replace meshcode.exe.
     if sys.platform == "win32":
         cmd = (f'set "CLAUDECODE=" & set "CLAUDE_CODE_SESSION=" & '
-               f'set "MESHCODE_NO_AUTO_UPDATE=1" & set "MESHCODE_NO_UPDATE=1" & '
-               f'"{bin_}" run "{target}"')
+               f'set "MESHCODE_NO_UPDATE=" & set "MESHCODE_NO_AUTO_UPDATE=" & '
+               f'"{sys.executable}" -m meshcode run "{target}"')
     else:
-        cmd = (f"unset CLAUDECODE CLAUDE_CODE_SESSION; export MESHCODE_NO_AUTO_UPDATE=1; "
-               f"export MESHCODE_NO_UPDATE=1; exec {shlex.quote(bin_)} run {shlex.quote(target)}")
+        cmd = (f"unset CLAUDECODE CLAUDE_CODE_SESSION MESHCODE_NO_UPDATE MESHCODE_NO_AUTO_UPDATE; "
+               f"exec {shlex.quote(sys.executable)} -m meshcode run {shlex.quote(target)}")
     try:
         from meshcode import protocol_handler as _ph
         ok, info = _ph._spawn_terminal(cmd)
@@ -485,12 +493,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)
@@ -524,6 +584,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.74 → meshcode-2.11.76}/meshcode/run_agent.py

@@ -698,13 +698,14 @@ def run(agent: str, project: Optional[str] = None, editor_override: Optional[str
     # Propagate autonomous flag to the editor + MCP child via env var.
     if autonomous:
         os.environ["MESHCODE_AUTONOMOUS"] = "1"
-    # Blocking self-update: pip install -U meshcode BEFORE spawning the
-    # editor so the child MCP subprocess loads the freshest server.py off
-    # disk. Skip in dry-run — CI / pre-publish smokes must not fork pip.
-    # See claude_update_blocking below for the npm/Claude Code half.
+    # NON-BLOCKING self-update (task 14782bb4): kick a detached background `pip install -U meshcode`
+    # and return IMMEDIATELY — the launch NEVER waits/hangs (Samuel req; the old blocking variant hung
+    # every Windows launch on WinError 32). This launch runs the current version; the next spawn/recycle
+    # picks up the new one (two-launch async). Skip in dry-run (CI/pre-publish smokes must not fork pip).
+    # Fully opt-out via MESHCODE_NO_UPDATE / MESHCODE_NO_AUTO_UPDATE (handled inside check_and_maybe_update).
     if not dry_run:
         try:
-            self_update.check_and_maybe_update_blocking()
+            self_update.check_and_maybe_update()
         except Exception:
             pass
 

{meshcode-2.11.74 → meshcode-2.11.76}/meshcode.egg-info/PKG-INFO

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

meshcode-2.11.74/meshcode.egg-info/SOURCES 2.txt → meshcode-2.11.76/meshcode.egg-info/SOURCES.txt

@@ -5,9 +5,6 @@ meshcode/__main__.py
 meshcode/_stop_hook_template.py
 meshcode/ascii_art.py
 meshcode/atomic_push.py
-meshcode/claude_update 2.py
-meshcode/claude_update 3.py
-meshcode/claude_update 4.py
 meshcode/claude_update.py
 meshcode/cli.py
 meshcode/comms_v4.py
@@ -17,9 +14,6 @@ meshcode/date_parse.py
 meshcode/doctor.py
 meshcode/error_hints.py
 meshcode/exceptions.py
-meshcode/hostd 2.py
-meshcode/hostd 3.py
-meshcode/hostd 4.py
 meshcode/hostd.py
 meshcode/invites.py
 meshcode/launcher.py
@@ -34,8 +28,6 @@ meshcode/secrets.py
 meshcode/self_update.py
 meshcode/setup_clients.py
 meshcode/supervisor.py
-meshcode/up 2.py
-meshcode/up 3.py
 meshcode/up.py
 meshcode/upload.py
 meshcode-backend-wt/comms_v4.py
@@ -212,10 +204,6 @@ 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 2.py
-tests/test_autonomous_prompt_inject 3.py
-tests/test_autonomous_prompt_inject 4.py
-tests/test_autonomous_prompt_inject 5.py
 tests/test_autonomous_prompt_inject.py
 tests/test_boot_bug_regression.py
 tests/test_color_truecolor.py

{meshcode-2.11.74 → meshcode-2.11.76}/pyproject.toml

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