meshcode 2.11.82__tar.gz → 2.11.84__tar.gz

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

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

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

{meshcode-2.11.82 → meshcode-2.11.84}/meshcode/hostd.py

@@ -36,6 +36,7 @@ import json
 import os
 import shlex
 import shutil
+import signal as _signal
 import subprocess
 import sys
 import time
@@ -219,6 +220,11 @@ 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",
                             "MESHCODE_NO_UPDATE", "MESHCODE_NO_AUTO_UPDATE")}
+        # LAUNCH-NO-WINDOW (task 35bee961): tell run_agent it's headless so it spawns
+        # the Claude Code child with CREATE_NO_WINDOW. Without this, our DETACHED_PROCESS
+        # python parent (no console) spawns `cmd.exe /c claude.cmd` and Windows ALLOCATES
+        # A FRESH CONSOLE WINDOW for the child -> a terminal pops up despite "headless".
+        env["MESHCODE_HEADLESS"] = "1"
         log_dir = STATE_DIR / "logs"
         try:
             log_dir.mkdir(parents=True, exist_ok=True)
@@ -255,8 +261,12 @@ def _spawn_agent(project: str, agent: str, headless: bool = False) -> bool:
         try:
             # `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})")
+            proc = subprocess.Popen([sys.executable, "-m", "meshcode", "run", target], **kwargs)
+            # LAUNCH-NO-WINDOW (task 35bee961): record the headless PID so the Stop sweep
+            # (_do_stops) can hard-kill it — a headless agent has NO window for Samuel to
+            # close, so desired_state='stopped' must be enforced by killing the process.
+            _record_headless_pid(target, proc.pid)
+            _log(f"spawned {target} HEADLESS (no window, {sys.platform}; pid={proc.pid}; log={log_path})")
             return True
         except Exception as e:
             _log(f"WARN: headless spawn {target} failed: {e}")
@@ -364,6 +374,151 @@ def _save_state(st: dict) -> None:
         pass
 
 
+# ------------------------------------------------------------------
+# Stop — hard-kill a HEADLESS agent (task 35bee961). A headless agent has no
+# window Samuel can close, so a Stop (desired_state='stopped') that the agent
+# doesn't honor cooperatively (must_exit) would otherwise run forever. We record
+# each headless spawn's PID (persisted across hostd restarts) and kill it when the
+# cloud says it should be stopped but it's still heartbeating.
+# ------------------------------------------------------------------
+
+def _record_headless_pid(target: str, pid: int) -> None:
+    try:
+        st = _load_state()
+        pids = st.get("headless_pids") or {}
+        pids[target] = pid
+        st["headless_pids"] = pids
+        _save_state(st)
+    except Exception:
+        pass
+
+
+def _pid_cmdline(pid: int) -> str:
+    """Best-effort command line for a pid (to avoid killing a reused PID). '' on failure."""
+    try:
+        if sys.platform == "win32":
+            out = subprocess.run(
+                ["wmic", "process", "where", f"ProcessId={pid}", "get", "CommandLine"],
+                capture_output=True, text=True, timeout=5).stdout
+        else:
+            out = subprocess.run(
+                ["ps", "-o", "args=", "-p", str(pid)],
+                capture_output=True, text=True, timeout=5).stdout
+        return out or ""
+    except Exception:
+        return ""
+
+
+def _discover_agent_pids(target: str) -> list:
+    """Fallback PID discovery by command line, for agents spawned before this hostd
+    (no recorded PID) or after a state-file loss. Matches `meshcode run <target>`.
+    Best-effort; returns [] on any failure."""
+    pids = []
+    try:
+        if sys.platform == "win32":
+            out = subprocess.run(
+                ["wmic", "process", "where", "name='python.exe'", "get", "ProcessId,CommandLine", "/FORMAT:LIST"],
+                capture_output=True, text=True, timeout=8).stdout
+            block_pid = None
+            for line in out.splitlines():
+                line = line.strip()
+                if line.startswith("CommandLine="):
+                    block_pid = ("meshcode" in line and f"run {target}" in line)
+                elif line.startswith("ProcessId=") and block_pid:
+                    try:
+                        pids.append(int(line.split("=", 1)[1]))
+                    except Exception:
+                        pass
+                    block_pid = None
+        else:
+            out = subprocess.run(
+                ["pgrep", "-f", f"meshcode run {target}"],
+                capture_output=True, text=True, timeout=8).stdout
+            for ln in out.split():
+                try:
+                    pids.append(int(ln))
+                except Exception:
+                    pass
+    except Exception:
+        pass
+    return pids
+
+
+def _kill_headless_pid(target: str, pid: int) -> bool:
+    """Hard-kill a recorded headless PID + its child tree. Guards against PID reuse by
+    confirming the cmdline still looks like this meshcode agent. Returns True if killed."""
+    if not pid:
+        return False
+    cl = _pid_cmdline(pid).lower()
+    # Reuse guard: a headless agent's process is either `python -m meshcode run ...`
+    # (Windows: parent stays alive) or `claude ...` (POSIX: execvp'd to the editor). If
+    # we got a cmdline and it's NEITHER, the PID was reused by something unrelated — skip.
+    if cl and ("meshcode" not in cl and "claude" not in cl):
+        _log(f"STOP {target}: pid {pid} cmdline no longer matches (reused) — skip kill")
+        return False
+    try:
+        if sys.platform == "win32":
+            # /T kills the whole tree (python parent + cmd.exe + claude child), /F forces.
+            subprocess.run(["taskkill", "/PID", str(pid), "/T", "/F"],
+                           capture_output=True, timeout=10)
+        else:
+            try:
+                os.killpg(os.getpgid(pid), _signal.SIGTERM)  # start_new_session => own group
+            except Exception:
+                os.kill(pid, _signal.SIGTERM)
+            time.sleep(1.5)
+            try:
+                os.kill(pid, 0)            # still alive?
+                os.killpg(os.getpgid(pid), _signal.SIGKILL)
+            except ProcessLookupError:
+                pass
+            except Exception:
+                try:
+                    os.kill(pid, _signal.SIGKILL)
+                except Exception:
+                    pass
+        _log(f"STOP {target}: hard-killed headless pid {pid}")
+        return True
+    except Exception as e:
+        _log(f"WARN: STOP {target} kill pid {pid} failed: {e}")
+        return False
+
+
+def _do_stops(api_key: str, host_id: str) -> int:
+    """One stop sweep: hard-kill headless agents the cloud marked stopped but that are
+    still alive (cooperative must_exit didn't land). Returns number killed."""
+    res = _rpc("mc_agents_to_stop", {"p_api_key": api_key, "p_host_id": host_id})
+    if not res or not res.get("ok"):
+        return 0
+    agents = res.get("agents") or []
+    if not agents:
+        return 0
+    st = _load_state()
+    pids = st.get("headless_pids") or {}
+    n = 0
+    for a in agents:
+        proj, agent = a.get("project_name"), a.get("agent")
+        if not proj or not agent:
+            continue
+        target = f"{proj}/{agent}"
+        pid = pids.get(target)
+        killed = bool(pid) and _kill_headless_pid(target, pid)
+        if pid and killed:
+            pids.pop(target, None)
+        if not killed:
+            # No recorded PID (spawned by an older hostd / state lost) OR the recorded
+            # PID was stale — discover by command line and kill.
+            for dpid in _discover_agent_pids(target):
+                if _kill_headless_pid(target, dpid):
+                    killed = True
+            pids.pop(target, None)
+        if killed:
+            n += 1
+    st["headless_pids"] = pids
+    _save_state(st)
+    return n
+
+
 def _do_recycles(api_key: str, host_id: str) -> int:
     """Uptime-based recycle at task boundary. Returns number recycled."""
     cfg = _rpc("mc_host_config_get", {"p_api_key": api_key, "p_host_id": host_id})
@@ -811,6 +966,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 +983,22 @@ 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)
-                        if relaunched or recycled or ver_recycled:
-                            _log(f"sweep done — {relaunched} respawned, {recycled} recycled, {ver_recycled} version-recycled")
+                        stopped = _do_stops(api_key, host_id)
+                        _up = int(time.monotonic() - _spawn_mono)
+                        if relaunched or recycled or ver_recycled or stopped:
+                            _log(f"sweep done (uptime={_up}s) — {relaunched} respawned, {recycled} recycled, {ver_recycled} version-recycled, {stopped} stopped")
+                        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)

{meshcode-2.11.82 → meshcode-2.11.84}/meshcode/protocol_handler.py

@@ -117,8 +117,12 @@ def _spawn_terminal_windows(cmd: str) -> tuple[bool, str]:
             wt = str(cand)
     if wt:
         try:
-            # `wt -w 0 nt` opens a new tab in existing window
-            subprocess.Popen([wt, "-w", "0", "nt", "cmd", "/k", cmd])
+            # LAUNCH-NO-WINDOW (task 35bee961, commander-corrected): `-w new` forces a
+            # BRAND-NEW Windows Terminal window (freshly created => FOREGROUND/focused), which
+            # is what Samuel wants ("ventana nueva ENFOCADA"). The old `-w 0 nt` opened a tab in
+            # the most-recently-used window — frequently minimized/background, so the launch
+            # looked like "nada pasó".
+            subprocess.Popen([wt, "-w", "new", "nt", "cmd", "/k", cmd])
             return True, "wt"
         except Exception as e:
             return False, f"wt.exe: {e}"

{meshcode-2.11.82 → meshcode-2.11.84}/meshcode/run_agent.py

@@ -1082,7 +1082,23 @@ def run(agent: str, project: Optional[str] = None, editor_override: Optional[str
             if use_shell:
                 print(f"[meshcode]   (Windows: launching via shell for .cmd wrapper)")
             launch_cwd = str(ws) if os.path.isdir(ws) else None
-            result = _sp.run(cmd, shell=use_shell, cwd=launch_cwd)
+            # LAUNCH-NO-WINDOW (task 35bee961): when hostd spawned us HEADLESS, our parent
+            # python has NO console (DETACHED_PROCESS|CREATE_NO_WINDOW). Spawning the Claude
+            # child here WITHOUT CREATE_NO_WINDOW makes Windows allocate a FRESH console
+            # window for it -> a terminal pops up despite "headless". Pass CREATE_NO_WINDOW so
+            # the child stays windowless too. Detect headless via the env flag hostd sets, OR
+            # by having no console of our own (GetConsoleWindow()==0) as a belt-and-suspenders.
+            _kwargs = {"shell": use_shell, "cwd": launch_cwd}
+            _headless = os.environ.get("MESHCODE_HEADLESS", "").lower() in ("1", "true", "yes")
+            if not _headless:
+                try:
+                    import ctypes as _ct
+                    _headless = _ct.windll.kernel32.GetConsoleWindow() == 0
+                except Exception:
+                    _headless = False
+            if _headless:
+                _kwargs["creationflags"] = 0x08000000  # CREATE_NO_WINDOW
+            result = _sp.run(cmd, **_kwargs)
             sys.exit(result.returncode)
         else:
             # Unix: replace this process with the editor

{meshcode-2.11.82 → meshcode-2.11.84}/meshcode/setup_clients.py

@@ -254,6 +254,79 @@ def _toml_escape(s: str) -> str:
     return s.replace("\\", "\\\\").replace("\"", "\\\"")
 
 
+def _stop_hook_command() -> str:
+    """Windows-safe Stop-hook command string for .claude/settings.json.
+
+    WIN-HOOKS-PYTHON3-TEMPLATE (task 77581e18): a bare ``python3`` resolves to
+    the Microsoft Store stub on Windows — it exits non-zero and the hook
+    silently no-ops, so stay_on_loop (and the PreCompact/SessionStart handoff
+    hooks) never fire on Windows. Resolve the interpreter to the absolute path
+    of the process running this scaffolder (same idiom as the MCP server
+    command, see ~line 219: ``sys.executable or "python3"``), in POSIX slash
+    form so the path is safe to quote under BOTH ``sh -c`` (macOS/Linux) and
+    Git Bash (Windows). The script is still referenced via
+    ``$CLAUDE_PROJECT_DIR`` — Claude Code substitutes that placeholder itself
+    before invoking the shell, cross-platform, so ``python3`` was the only
+    break. Shell form (single command string) is kept over the exec
+    ``args`` form for backward-compatibility with older Claude Code builds
+    that predate the ``args`` field.
+    """
+    interp = (
+        Path(sys.executable).as_posix() if sys.executable
+        else ("py" if sys.platform == "win32" else "python3")
+    )
+    return f'"{interp}" "$CLAUDE_PROJECT_DIR/.claude/hooks/stay_on_loop.py"'
+
+
+def _heal_settings_stop_hook(ws: Path, dry_run: bool = False):
+    """Self-heal the Stop-hook command in ws/.claude/settings.json.
+
+    WIN-HOOKS-PYTHON3-TEMPLATE deliverable 2: rewriting only the hook .py body
+    leaves existing Windows workspaces broken because their settings.json still
+    carries the legacy ``python3 "$CLAUDE_PROJECT_DIR/..."`` command (the
+    MS-Store stub). Surgically replace just the command of any Stop hook that
+    references ``stay_on_loop.py`` and differs from the Windows-safe form —
+    every other key/hook in the file is preserved, so a user who added their
+    own hooks does not get clobbered. Missing settings.json is backfilled.
+
+    Returns ``(changed: bool, note: str)``.
+    """
+    settings_path = ws / ".claude" / "settings.json"
+    desired = _stop_hook_command()
+    if not settings_path.exists():
+        if dry_run:
+            return True, "would create settings.json"
+        try:
+            settings_path.parent.mkdir(parents=True, exist_ok=True)
+            settings_path.write_text(json.dumps({
+                "hooks": {"Stop": [{"hooks": [{"type": "command", "command": desired}]}]},
+            }, indent=2) + "\n", encoding="utf-8")
+            return True, "created settings.json"
+        except Exception as e:  # noqa: BLE001 — best-effort heal
+            return False, f"settings.json create failed: {e}"
+    try:
+        data = json.loads(settings_path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError) as e:
+        return False, f"settings.json unreadable ({e}) — left untouched"
+    changed = False
+    for entry in ((data or {}).get("hooks") or {}).get("Stop") or []:
+        for hook in (entry.get("hooks") or []):
+            cmd = hook.get("command")
+            if isinstance(cmd, str) and "stay_on_loop.py" in cmd and cmd != desired:
+                changed = True
+                if not dry_run:
+                    hook["command"] = desired
+    if not changed:
+        return False, "settings.json already current"
+    if dry_run:
+        return True, "would patch settings.json"
+    try:
+        settings_path.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
+    except Exception as e:  # noqa: BLE001
+        return False, f"settings.json write failed: {e}"
+    return True, "patched settings.json"
+
+
 def _render_codex_block(server_id: str, server_block: Dict[str, Any]) -> str:
     """Render a [mcp_servers.<server_id>] section (plus [.env] subtable) for
     Codex CLI's ~/.codex/config.toml format. Returns a text block starting
@@ -1337,7 +1410,7 @@ Call `meshcode_wait` now.
             "Stop": [{
                 "hooks": [{
                     "type": "command",
-                    "command": "python3 \"$CLAUDE_PROJECT_DIR/.claude/hooks/stay_on_loop.py\"",
+                    "command": _stop_hook_command(),
                 }],
             }],
         },
@@ -1582,19 +1655,32 @@ def patch_hooks(dry_run: bool = False) -> int:
         try:
             existing = hook_path.read_text(encoding="utf-8") if hook_path.exists() else ""
             if existing == _STOP_HOOK_BODY:
-                skipped.append(f"{ws.name} (already current)")
-                continue
-            if dry_run:
-                patched.append(f"{ws.name} (would patch)")
-                continue
-            hook_path.write_text(_STOP_HOOK_BODY, encoding="utf-8")
-            try:
-                hook_path.chmod(0o755)
-            except OSError:
-                pass
-            patched.append(ws.name)
+                body_note = "body current"
+            elif dry_run:
+                body_note = "body would patch"
+            else:
+                hook_path.write_text(_STOP_HOOK_BODY, encoding="utf-8")
+                try:
+                    hook_path.chmod(0o755)
+                except OSError:
+                    pass
+                body_note = "body patched"
         except Exception as e:
             failed.append((ws.name, str(e)))
+            continue
+
+        # WIN-HOOKS-PYTHON3-TEMPLATE deliverable 2: patching the .py body alone
+        # leaves the legacy `python3` command in settings.json (MS-Store stub on
+        # Windows), so always self-heal settings.json too — independent of body
+        # status, since a workspace can have a current body but a stale command.
+        try:
+            settings_changed, settings_note = _heal_settings_stop_hook(ws, dry_run)
+        except Exception as e:  # noqa: BLE001 — never let one ws abort the sweep
+            settings_changed, settings_note = False, f"settings heal failed: {e}"
+
+        body_changed = body_note in ("body patched", "body would patch")
+        record = f"{ws.name} ({body_note}; {settings_note})"
+        (patched if (body_changed or settings_changed) else skipped).append(record)
 
     verb = "would patch" if dry_run else "patched"
     print(f"[meshcode patch-hooks] {verb} {len(patched)} workspace(s):")

{meshcode-2.11.82 → meshcode-2.11.84}/meshcode.egg-info/PKG-INFO

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

meshcode-2.11.84/meshcode.egg-info/SOURCES.txt

@@ -0,0 +1,88 @@
+README.md
+pyproject.toml
+meshcode/__init__.py
+meshcode/__main__.py
+meshcode/_stop_hook_template.py
+meshcode/ascii_art.py
+meshcode/atomic_push.py
+meshcode/claude_update.py
+meshcode/cli.py
+meshcode/comms_v4.py
+meshcode/compat.py
+meshcode/daemon.py
+meshcode/date_parse.py
+meshcode/doctor.py
+meshcode/error_hints.py
+meshcode/exceptions.py
+meshcode/hostd.py
+meshcode/invites.py
+meshcode/launcher.py
+meshcode/launcher_install.py
+meshcode/preferences.py
+meshcode/protocol_handler.py
+meshcode/protocol_v2.py
+meshcode/quickstart.py
+meshcode/rpc_allowlist.py
+meshcode/run_agent.py
+meshcode/secrets.py
+meshcode/self_update.py
+meshcode/setup_clients.py
+meshcode/supervisor.py
+meshcode/up.py
+meshcode/upload.py
+meshcode.egg-info/PKG-INFO
+meshcode.egg-info/SOURCES.txt
+meshcode.egg-info/dependency_links.txt
+meshcode.egg-info/entry_points.txt
+meshcode.egg-info/requires.txt
+meshcode.egg-info/top_level.txt
+meshcode/meshcode_mcp/__init__.py
+meshcode/meshcode_mcp/__main__.py
+meshcode/meshcode_mcp/backend.py
+meshcode/meshcode_mcp/realtime.py
+meshcode/meshcode_mcp/server.py
+meshcode/meshcode_mcp/sleep_signals.py
+meshcode/meshcode_mcp/test_backend.py
+meshcode/meshcode_mcp/test_boot_timing.py
+meshcode/meshcode_mcp/test_install_guard.py
+meshcode/meshcode_mcp/test_prefs_claude_version.py
+meshcode/meshcode_mcp/test_realtime.py
+meshcode/meshcode_mcp/test_server_wrapper.py
+meshcode/scripts/check_secrets.py
+meshcode/scripts/race_rate_harness.py
+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.py
+tests/test_boot_bug_regression.py
+tests/test_color_truecolor.py
+tests/test_core.py
+tests/test_cross_agent_messaging.py
+tests/test_date_parse.py
+tests/test_doctor.py
+tests/test_epistemic_v1_python_sdk.py
+tests/test_epistemic_v1_stop_conditions.py
+tests/test_esc_deaf_state.py
+tests/test_exceptions.py
+tests/test_file_upload.py
+tests/test_init_device_code.py
+tests/test_install_guard.py
+tests/test_lease_sigterm_release.py
+tests/test_mark_read_batch.py
+tests/test_marketplace_ratings.py
+tests/test_migration_integrity.py
+tests/test_realtime_event_freshness.py
+tests/test_rls_cross_tenant.py
+tests/test_rpc_grants.py
+tests/test_rpc_migrations.py
+tests/test_run_agent_dry_run.py
+tests/test_run_agent_no_server_import.py
+tests/test_security_regressions.py
+tests/test_self_update_user_site.py
+tests/test_sentinel.py
+tests/test_setup_path.py
+tests/test_sleep_signals.py
+tests/test_status_enum_coverage.py
+tests/test_stay_on_loop_hook.py
+tests/test_wait_open_tasks_contradiction.py

meshcode-2.11.84/meshcode.egg-info/top_level.txt

@@ -0,0 +1 @@
+meshcode

{meshcode-2.11.82 → meshcode-2.11.84}/pyproject.toml

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