meshcode 2.11.83__tar.gz → 2.11.85__tar.gz

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

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

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

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

meshcode-2.11.85/meshcode/_session_handoff_template.py

@@ -0,0 +1,245 @@
+"""Session-handoff hook templates — single source of truth for the
+PreCompact (write) + SessionStart (read) hooks.
+
+CTX-CLOSE-RELAUNCH (task bcd157a9, backend2): when a commander/agent session
+gets recycled at high context — either by Claude Code's in-place autocompact
+or by a clean close+relaunch — the IN-FLIGHT working context (which task I was
+mid-executing, what I just edited/decided this session) is lost. meshcode_boot
+restores mesh state (tasks, inbox, memory) authoritatively, but NOT the
+conversational thread. These two hooks bridge that gap:
+
+  * PreCompact  -> session_handoff_write.py: dump a compact snapshot of the
+    recent transcript tail to .claude/handoff.json BEFORE the context is
+    compacted/the session exits. Pure local file I/O — no creds, no network,
+    no MCP — so it is safe to run in any hook subprocess on any platform.
+  * SessionStart -> session_handoff_read.py: on the next (fresh) session,
+    inject that snapshot back as additionalContext so the agent resumes the
+    thread, then archive it so it is injected exactly once.
+
+Stored as string constants (same pattern as _stop_hook_template.py) so
+`meshcode patch-hooks` can backfill existing workspaces without a full
+re-scaffold. The recycle TRIGGER itself (mc_request_recycle / wait-loop
+must_exit=recycle / hostd context branch) is owned by the daemon/server side
+and is intentionally NOT in these scripts — handoff preservation is decoupled
+from whatever causes the restart, so it works for autocompact, clean recycle,
+crash-respawn, or a manual relaunch alike.
+"""
+
+# Shared constants kept in sync between the two bodies.
+_HANDOFF_FILENAME = "handoff.json"
+_HANDOFF_MAX_TURNS = 24          # transcript tail entries to preserve
+_HANDOFF_MAX_CHARS_PER_TURN = 1200
+_HANDOFF_MAX_AGE_S = 24 * 3600   # ignore stale handoffs on read
+
+HANDOFF_WRITE_BODY = '''#!/usr/bin/env python3
+"""PreCompact hook: snapshot the recent transcript tail to .claude/handoff.json
+so a fresh post-recycle session can resume the in-flight thread.
+
+CTX-CLOSE-RELAUNCH (task bcd157a9). Pure local file I/O — never touches the
+network, never imports meshcode, never blocks. Any failure is swallowed and the
+hook exits 0 so it can NEVER stall or break a Claude Code compaction/exit.
+
+Claude Code passes a JSON event on stdin:
+  {"hook_event_name":"PreCompact","session_id":..,"transcript_path":..,
+   "trigger":"auto"|"manual", ...}
+"""
+import json
+import os
+import sys
+from pathlib import Path
+
+MAX_TURNS = 24
+MAX_CHARS_PER_TURN = 1200
+
+
+def _project_dir() -> Path:
+    # Claude Code exports CLAUDE_PROJECT_DIR for hooks; fall back to cwd.
+    return Path(os.environ.get("CLAUDE_PROJECT_DIR") or os.getcwd())
+
+
+def _text_from_message(msg) -> str:
+    """Flatten a transcript message's content into plain text + tool markers."""
+    if isinstance(msg, str):
+        return msg
+    if not isinstance(msg, dict):
+        return ""
+    content = msg.get("content")
+    if isinstance(content, str):
+        return content
+    parts = []
+    if isinstance(content, list):
+        for block in content:
+            if not isinstance(block, dict):
+                continue
+            btype = block.get("type")
+            if btype == "text" and block.get("text"):
+                parts.append(str(block["text"]))
+            elif btype == "tool_use":
+                parts.append(f"[tool_use:{block.get('name','?')}]")
+            elif btype == "tool_result":
+                parts.append("[tool_result]")
+    return " ".join(parts).strip()
+
+
+def _extract_tail(transcript_path: str):
+    """Return up to MAX_TURNS (role, text) tuples from the end of the JSONL
+    transcript, skipping empty / meta-only entries."""
+    p = Path(transcript_path) if transcript_path else None
+    if not p or not p.exists():
+        return []
+    rows = []
+    try:
+        with p.open("r", encoding="utf-8", errors="replace") as fh:
+            for line in fh:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    obj = json.loads(line)
+                except (json.JSONDecodeError, ValueError):
+                    continue
+                msg = obj.get("message") if isinstance(obj, dict) else None
+                role = (obj.get("type") or (msg or {}).get("role") or "").strip()
+                if role not in ("user", "assistant", "human"):
+                    continue
+                text = _text_from_message(msg if msg is not None else obj)
+                if not text:
+                    continue
+                if len(text) > MAX_CHARS_PER_TURN:
+                    text = text[:MAX_CHARS_PER_TURN] + " …[truncated]"
+                rows.append(("user" if role in ("user", "human") else "assistant", text))
+    except OSError:
+        return []
+    return rows[-MAX_TURNS:]
+
+
+def main() -> int:
+    try:
+        raw = sys.stdin.read()
+        event = json.loads(raw) if raw.strip() else {}
+    except (json.JSONDecodeError, ValueError):
+        event = {}
+
+    tail = _extract_tail(event.get("transcript_path", ""))
+    handoff = {
+        "schema": 1,
+        "session_id": event.get("session_id"),
+        "trigger": event.get("trigger") or event.get("hook_event_name") or "precompact",
+        "agent": os.environ.get("MESHCODE_AGENT"),
+        "project": os.environ.get("MESHCODE_PROJECT"),
+        "turns": [{"role": r, "text": t} for (r, t) in tail],
+    }
+    try:
+        d = _project_dir() / ".claude"
+        d.mkdir(parents=True, exist_ok=True)
+        tmp = d / "handoff.json.tmp"
+        tmp.write_text(json.dumps(handoff, ensure_ascii=False, indent=2), encoding="utf-8")
+        tmp.replace(d / "handoff.json")
+    except OSError as e:
+        sys.stderr.write(f"[session_handoff_write] skipped: {e}\\n")
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except Exception as e:  # never break compaction
+        sys.stderr.write(f"[session_handoff_write] error: {e}\\n")
+        sys.exit(0)
+'''
+
+HANDOFF_READ_BODY = '''#!/usr/bin/env python3
+"""SessionStart hook: if a handoff snapshot exists, inject it as
+additionalContext so a freshly-recycled session resumes the in-flight thread,
+then archive it so it is injected exactly once.
+
+CTX-CLOSE-RELAUNCH (task bcd157a9). Pure local file I/O — no network, no
+meshcode import, never blocks. meshcode_boot remains authoritative for mesh
+state; this only restores the conversational thread.
+
+Claude Code passes a JSON event on stdin:
+  {"hook_event_name":"SessionStart","source":"startup"|"resume"|"compact",..}
+and reads our additionalContext from this hook's stdout JSON:
+  {"hookSpecificOutput":{"hookEventName":"SessionStart","additionalContext":..}}
+"""
+import json
+import os
+import sys
+import time
+from pathlib import Path
+
+MAX_AGE_S = 24 * 3600
+
+
+def _project_dir() -> Path:
+    return Path(os.environ.get("CLAUDE_PROJECT_DIR") or os.getcwd())
+
+
+def _emit(context: str) -> None:
+    sys.stdout.write(json.dumps({
+        "hookSpecificOutput": {
+            "hookEventName": "SessionStart",
+            "additionalContext": context,
+        }
+    }))
+
+
+def _render(handoff: dict) -> str:
+    turns = handoff.get("turns") or []
+    if not turns:
+        return ""
+    lines = [
+        "## Recovered session handoff (CTX-CLOSE-RELAUNCH)",
+        "",
+        "Your previous session was recycled at high context. meshcode_boot has "
+        "the authoritative mesh state (tasks/inbox/memory); the thread tail "
+        "below is the in-flight context that boot does not restore. Use it to "
+        "resume what you were mid-doing, then run the normal boot loop.",
+        "",
+        f"_trigger: {handoff.get('trigger','?')} · turns preserved: {len(turns)}_",
+        "",
+    ]
+    for t in turns:
+        role = (t.get("role") or "?").upper()
+        text = (t.get("text") or "").strip()
+        if text:
+            lines.append(f"**{role}:** {text}")
+            lines.append("")
+    return "\\n".join(lines).strip()
+
+
+def main() -> int:
+    path = _project_dir() / ".claude" / "handoff.json"
+    if not path.exists():
+        return 0
+    try:
+        handoff = json.loads(path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, ValueError, OSError):
+        return 0
+
+    # Ignore stale snapshots (mtime-based; avoids resurrecting old threads).
+    try:
+        if (time.time() - path.stat().st_mtime) > MAX_AGE_S:
+            path.replace(path.with_suffix(".stale.json"))
+            return 0
+    except OSError:
+        pass
+
+    context = _render(handoff)
+    if context:
+        _emit(context)
+    # Archive so the handoff is injected exactly once.
+    try:
+        path.replace(path.with_suffix(".consumed.json"))
+    except OSError:
+        pass
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except Exception as e:
+        sys.stderr.write(f"[session_handoff_read] error: {e}\\n")
+        sys.exit(0)
+'''

{meshcode-2.11.83 → meshcode-2.11.85}/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
@@ -260,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}")
@@ -369,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})
@@ -833,9 +983,10 @@ 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)
+                        stopped = _do_stops(api_key, host_id)
                         _up = int(time.monotonic() - _spawn_mono)
-                        if relaunched or recycled or ver_recycled:
-                            _log(f"sweep done (uptime={_up}s) — {relaunched} respawned, {recycled} recycled, {ver_recycled} version-recycled")
+                        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()

{meshcode-2.11.83 → meshcode-2.11.85}/meshcode/protocol_handler.py

@@ -117,9 +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 (Samuel-confirmed visible+focused
-            # on his box — task 35bee961 live test: keep -w 0).
-            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}"