meshcode 2.11.72__tar.gz → 2.11.74__tar.gz

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

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

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

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

{meshcode-2.11.72 → meshcode-2.11.74}/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.74/meshcode/hostd.py

@@ -0,0 +1,576 @@
+"""meshcode hostd — host-side daemon: respawn + recycle managed agents.
+
+Complements supervisor.py (launchd KeepAlive = process-exit restart only).
+hostd polls the CLOUD for staleness (heartbeat) + recycle triggers that
+launchd cannot see:
+
+  - RESPAWN: agent's heartbeat is stale (process/daemon-thread dead) and
+    desired_state='running' → relaunch. Loop-guard cap 3/10min → 'crashed'.
+  - RECYCLE: managed agent exceeds its recycle policy (context% or uptime)
+    → relaunch at a task boundary (never mid-task). Recorded separately
+    from the crash cap.
+
+Contract (mig366/367/368/369, DBA-cleared):
+  mc_register_host, mc_agents_needing_respawn, mc_record_respawn,
+  mc_record_recycle, mc_set_desired_state, mc_host_recycle_policy.
+
+Source of truth is the cloud (mc_agents / mc_host_config), never local
+folders. host_id lives in ~/.meshcode/host_id (generated once).
+
+    meshcode hostd run       — run the daemon loop (foreground)
+    meshcode hostd status    — show this host's managed agents
+    meshcode hostd install   — install launchd trigger-start plist
+    meshcode hostd uninstall — remove it
+
+Design invariants:
+  - NEVER respawn desired_state != 'running' (NULL=unmanaged, stopped=
+    intentional, crashed=gave-up). The cloud RPC enforces this; we trust it.
+  - Single retry / capped respawn — never an infinite relaunch loop.
+  - Recycle only at task boundary: we relaunch a recycle candidate only
+    when it is NOT actively working (status not in working/online-busy) OR
+    the agent has self-flagged 'recycling'. Mid-task agents are skipped.
+"""
+from __future__ import annotations
+
+import json
+import os
+import shlex
+import subprocess
+import sys
+import time
+import urllib.request
+import uuid
+from pathlib import Path
+from typing import Optional
+
+STATE_DIR = Path.home() / ".meshcode"
+HOST_ID_PATH = STATE_DIR / "host_id"
+LOG_PATH = STATE_DIR / "hostd.log"
+
+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"}
+
+
+def _log(msg: str) -> None:
+    line = f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] {msg}"
+    print(line, file=sys.stderr)
+    try:
+        STATE_DIR.mkdir(parents=True, exist_ok=True)
+        with open(LOG_PATH, "a", encoding="utf-8") as f:
+            f.write(line + "\n")
+    except Exception:
+        pass
+
+
+def get_host_id() -> str:
+    """Read ~/.meshcode/host_id, generating a stable UUID on first use."""
+    try:
+        if HOST_ID_PATH.exists():
+            v = HOST_ID_PATH.read_text(encoding="utf-8").strip()
+            if v:
+                return v
+    except Exception:
+        pass
+    new_id = str(uuid.uuid4())
+    try:
+        STATE_DIR.mkdir(parents=True, exist_ok=True)
+        HOST_ID_PATH.write_text(new_id, encoding="utf-8")
+    except Exception:
+        pass
+    return new_id
+
+
+# ------------------------------------------------------------------
+# Cloud RPC (PostgREST) — self-contained urllib, no internal client dep
+# ------------------------------------------------------------------
+
+def _supabase_cfg() -> tuple:
+    # env first (explicit override), then fall back to the SAME resolution the
+    # rest of the CLI uses (comms_v4: env -> ~/.meshcode/env -> baked publishable
+    # default). hostd runs under launchd with NO env, so the old env-only lookup
+    # left it unable to reach the cloud at all ("SUPABASE_URL/KEY not set").
+    url = os.environ.get("SUPABASE_URL", "").rstrip("/")
+    key = os.environ.get("SUPABASE_KEY") or os.environ.get("MESHCODE_SUPABASE_ANON_KEY") or ""
+    if url and key:
+        return url, key
+    try:
+        from meshcode import comms_v4 as _c  # type: ignore
+        return (url or _c.SUPABASE_URL).rstrip("/"), (key or _c.SUPABASE_KEY)
+    except Exception:
+        return url, key
+
+
+def _api_key() -> Optional[str]:
+    """The meshcode agent/user api key, used as p_api_key in mc_ RPCs.
+
+    Resolution mirrors comms_v4._load_api_key_for_cli so hostd authenticates
+    the same way `meshcode run` does. CRITICAL: launchd starts hostd with NO
+    environment, so the key MUST be resolvable from the keychain (where
+    `meshcode login` stores it). The old code only checked env + a
+    wrong-shaped profiles.json, so launchd-started hostd always FATAL'd
+    ("no api key") and never registered -> dashboard launch had no host.
+    """
+    # 1) explicit env override
+    k = os.environ.get("MESHCODE_API_KEY")
+    if k:
+        return k
+    # 2) keychain — the actual store `meshcode login` writes to. Same source
+    #    comms_v4._load_api_key_for_cli() uses. This is the launchd fix.
+    try:
+        from meshcode import secrets as _secrets  # type: ignore
+        profile = os.environ.get("MESHCODE_KEYCHAIN_PROFILE") or _secrets.DEFAULT_PROFILE
+        key = _secrets.get_api_key(profile=profile) or ""
+        if key:
+            return key
+    except Exception:
+        pass
+    # 3) legacy per-profile state file fallback. Handles BOTH the flat
+    #    {name: {api_key}} and nested {"profiles": {name: {api_key}}} shapes
+    #    (the flat-only scan silently missed the nested writer).
+    try:
+        prof = STATE_DIR / "profiles.json"
+        if prof.exists():
+            data = json.loads(prof.read_text(encoding="utf-8"))
+            roots = []
+            if isinstance(data, dict):
+                roots.append(data)
+                if isinstance(data.get("profiles"), dict):
+                    roots.append(data["profiles"])
+            for root in roots:
+                for v in root.values():
+                    if isinstance(v, dict) and v.get("api_key"):
+                        return v["api_key"]
+    except Exception:
+        pass
+    return None
+
+
+def _rpc(fn: str, payload: dict) -> Optional[dict]:
+    """Call a PostgREST RPC. Returns parsed JSON or None on any failure."""
+    url, key = _supabase_cfg()
+    if not url or not key:
+        _log("WARN: SUPABASE_URL/KEY not set — cannot reach cloud")
+        return None
+    try:
+        req = urllib.request.Request(
+            f"{url}/rest/v1/rpc/{fn}",
+            data=json.dumps(payload).encode("utf-8"),
+            headers={
+                "apikey": key,
+                "Authorization": f"Bearer {key}",
+                "Content-Type": "application/json",
+            },
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+    except Exception as e:
+        _log(f"WARN: rpc {fn} failed: {e}")
+        return None
+
+
+# ------------------------------------------------------------------
+# Respawn
+# ------------------------------------------------------------------
+
+def _meshcode_bin() -> str:
+    cand = Path(sys.argv[0]).resolve()
+    if cand.exists() and cand.name.startswith("meshcode"):
+        return str(cand)
+    return "meshcode"
+
+
+def _spawn_agent(project: str, agent: str, headless: bool = False) -> bool:
+    """Relaunch `meshcode run <project>/<agent>`.
+
+    headless=False (default): VISIBLE terminal window. Samuel must SEE it — we
+    delegate to protocol_handler._spawn_terminal, the canonical visible spawner
+    (macOS: osascript-if-Automation-granted else `open` a .command wrapper, no TCC
+    needed; Linux/Windows: native terminals). On failure we WARN loudly and return
+    False — we NEVER silently fall back to headless when visible was asked.
+
+    headless=True (Fleet Control mig404 per-agent flag): background process, NO
+    window — for fleet agents that don't need a terminal (like the qa launch).
+    """
+    target = f"{project}/{agent}"
+    bin_ = _meshcode_bin()
+    if headless:
+        # 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).
+        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)
+        except Exception:
+            pass
+        safe = f"{project}__{agent}".replace("/", "_").replace("\\", "_")
+        log_path = log_dir / f"{safe}.headless.log"
+        logf = None
+        try:
+            logf = open(log_path, "ab")
+        except Exception:
+            logf = None
+        kwargs = {
+            "stdin": subprocess.DEVNULL,
+            "stdout": (logf if logf is not None else subprocess.DEVNULL),
+            "stderr": subprocess.STDOUT,
+            "env": env,
+        }
+        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).
+            kwargs["creationflags"] = 0x08000000 | 0x00000008
+            try:
+                scripts = str(Path(bin_).resolve().parent)
+            except Exception:
+                scripts = ""
+            sysroot = os.environ.get("SystemRoot", r"C:\Windows")
+            base_path = os.pathsep.join(p for p in (scripts, sysroot + r"\System32", sysroot) if p)
+            env["PATH"] = (base_path + os.pathsep + env.get("PATH", ""))[:30000]
+        else:
+            # 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)
+            _log(f"spawned {target} HEADLESS (no window, {sys.platform}; log={log_path})")
+            return True
+        except Exception as e:
+            _log(f"WARN: headless spawn {target} failed: {e}")
+            return False
+        finally:
+            # child inherited its own fd; safe to drop the daemon's handle.
+            if logf is not None:
+                try:
+                    logf.close()
+                except Exception:
+                    pass
+    # env hygiene (item1 RC): a stale CLAUDECODE aborts `meshcode run` (exit2). Build the terminal
+    # 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).
+    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}"')
+    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)}")
+    try:
+        from meshcode import protocol_handler as _ph
+        ok, info = _ph._spawn_terminal(cmd)
+        if ok:
+            _log(f"spawned {target} in visible terminal ({info})")
+            return True
+        _log(f"WARN: visible spawn {target} FAILED ({info}) — agent NOT launched. "
+             f"macOS: grant Terminal Automation (System Settings > Privacy & Security "
+             f"> Automation), or ensure `open` works. NOT falling back to headless.")
+        return False
+    except Exception as e:
+        _log(f"WARN: spawn {target} failed: {e}")
+        return False
+
+
+def _do_respawns(api_key: str, host_id: str) -> int:
+    """One respawn sweep. Returns number relaunched."""
+    res = _rpc("mc_agents_needing_respawn",
+               {"p_api_key": api_key, "p_host_id": host_id, "p_stale_seconds": STALE_SECONDS})
+    if not res or not res.get("ok"):
+        return 0
+    n = 0
+    for c in res.get("candidates", []):
+        proj, agent = c.get("project_name"), c.get("agent")
+        if not proj or not agent:
+            continue
+        if not c.get("respawn_allowed", True):
+            # mig404: not allowed = rate-limited (<60s since last respawn) or at the cap.
+            # mc_record_respawn v2 sets desired_state='crashed' ATOMICALLY at the cap, so we
+            # do NOT re-record here (that would inflate the count on a mere rate-limit skip).
+            _log(f"SKIP respawn {proj}/{agent}: not allowed (count={c.get('respawn_count')}, rate-limited/at-cap)")
+            continue
+        _log(f"RESPAWN {proj}/{agent} (stale {c.get('heartbeat_age_s')}s, count={c.get('respawn_count')})")
+        if _spawn_agent(proj, agent, headless=bool(c.get("headless"))):
+            rec = _rpc("mc_record_respawn",
+                       {"p_api_key": api_key, "p_project_id": c.get("project_id"), "p_agent_name": agent})
+            # mig404: give-up is ATOMIC inside mc_record_respawn (sets desired_state='crashed').
+            # The old mc_set_desired_state(p_state=crashed) call passed NO agent id = no-op; dropped.
+            if rec and rec.get("give_up"):
+                _log(f"ALERT {proj}/{agent}: respawn cap hit — marked crashed (atomic). No more respawns.")
+            n += 1
+    return n
+
+
+# ------------------------------------------------------------------
+# Recycle — relaunch a managed agent at a TASK BOUNDARY when it exceeds
+# its recycle policy. Uptime-recycle is daemon-driven (needs mig370's
+# project_name in the roster). Context-recycle is agent-cooperative (the
+# agent self-persists handoff + exits at a boundary; our respawn path then
+# relaunches it). Recorded via mc_record_recycle — NEVER counted against
+# the crash respawn cap.
+# ------------------------------------------------------------------
+
+_HOSTD_STATE_PATH = STATE_DIR / "hostd_state.json"
+
+
+def _load_state() -> dict:
+    try:
+        if _HOSTD_STATE_PATH.exists():
+            return json.loads(_HOSTD_STATE_PATH.read_text(encoding="utf-8"))
+    except Exception:
+        pass
+    return {}
+
+
+def _save_state(st: dict) -> None:
+    try:
+        STATE_DIR.mkdir(parents=True, exist_ok=True)
+        _HOSTD_STATE_PATH.write_text(json.dumps(st), encoding="utf-8")
+    except Exception:
+        pass
+
+
+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})
+    if not cfg or not cfg.get("ok"):
+        return 0
+    pol = _rpc("mc_host_recycle_policy", {"p_api_key": api_key, "p_host_id": host_id})
+    mode = (pol or {}).get("recycle_mode")
+    value = (pol or {}).get("recycle_value")
+    if mode != "time" or not value:
+        return 0  # context-recycle is agent-cooperative; only time is daemon-driven
+    st = _load_state()
+    now = time.time()
+    n = 0
+    seen = set()
+    for a in cfg.get("agents", []):
+        if a.get("desired_state") != "running":
+            continue
+        proj, agent = a.get("project_name"), a.get("name")
+        if not proj or not agent:
+            continue
+        key = f"{a.get('project_id')}/{agent}"
+        seen.add(key)
+        first = st.get(key)
+        if first is None:
+            st[key] = now  # start the uptime clock on first observation
+            continue
+        if (a.get("status") or "") in BUSY_STATUSES:
+            continue  # task boundary only — never mid-task
+        if (now - first) >= float(value) * 3600.0:
+            _log(f"RECYCLE {proj}/{agent} (uptime {(now-first)/3600:.1f}h >= {value}h)")
+            # Server-authorized clean-exit (task 548c863e, mig 364): SIGNAL the
+            # recycle instead of spawning. A direct _spawn_agent here duplicates
+            # the still-alive process. mc_request_recycle sets a flag; the
+            # agent's wait-loop consumes it, returns must_exit/reason=recycle,
+            # exits CLEAN (Stop-hook writes the handoff), then the respawn path
+            # (_do_respawns) relaunches it fresh. Recorded via mc_record_recycle
+            # so it's NEVER counted against the crash respawn cap.
+            req = _rpc("mc_request_recycle",
+                       {"p_api_key": api_key, "p_project_id": a.get("project_id"), "p_agent_name": agent})
+            if req and req.get("ok") and req.get("requested"):
+                _rpc("mc_record_recycle",
+                     {"p_api_key": api_key, "p_project_id": a.get("project_id"), "p_agent_name": agent})
+                st[key] = now  # reset clock after signaling recycle
+                n += 1
+            elif req and req.get("ok") and not req.get("requested"):
+                # Agent flipped busy between the roster read and the request —
+                # skip; retry next sweep at the next task boundary.
+                _log(f"SKIP recycle {proj}/{agent}: {req.get('reason','not_requested')}")
+    # prune state for agents no longer managed on this host
+    for k in [k for k in st if k not in seen]:
+        st.pop(k, None)
+    _save_state(st)
+    return n
+
+
+# ------------------------------------------------------------------
+# launchd trigger-start (macOS) — extends supervisor.py pattern.
+# The hostd daemon is NOT autostart-at-login: RunAtLoad=false. It is
+# kicked off on demand (button -> meshcode:// -> `launchctl kickstart`)
+# and KeepAlive keeps it alive while it runs. One job per host.
+# ------------------------------------------------------------------
+
+_HOSTD_PLIST_LABEL = "io.meshcode.hostd"
+
+
+def _hostd_plist_path():
+    return Path.home() / "Library" / "LaunchAgents" / f"{_HOSTD_PLIST_LABEL}.plist"
+
+
+def _hostd_plist_xml() -> str:
+    import shutil
+    mc = shutil.which("meshcode") or f"{sys.executable} -m meshcode"
+    args = (mc.split() + ["hostd", "run"]) if " -m " in mc else [mc, "hostd", "run"]
+    args_xml = "\n".join(f"        <string>{a}</string>" for a in args)
+    logdir = STATE_DIR / "logs"
+    logdir.mkdir(parents=True, exist_ok=True)
+    return f"""<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key><string>{_HOSTD_PLIST_LABEL}</string>
+    <key>ProgramArguments</key>
+    <array>
+{args_xml}
+    </array>
+    <key>RunAtLoad</key><false/>
+    <key>KeepAlive</key><true/>
+    <key>ThrottleInterval</key><integer>10</integer>
+    <key>StandardOutPath</key><string>{logdir / "hostd.stdout.log"}</string>
+    <key>StandardErrorPath</key><string>{logdir / "hostd.stderr.log"}</string>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key><string>/usr/local/bin:/usr/bin:/bin:{os.path.dirname(sys.executable)}</string>
+        <key>MESHCODE_NO_AUTO_UPDATE</key><string>1</string>
+    </dict>
+</dict>
+</plist>
+"""
+
+
+_HOSTD_TASK_NAME = "MeshCode hostd"
+
+
+def _hostd_install_windows() -> int:
+    """Windows Task Scheduler job (mesh-core ITEM2): at-logon, hidden, restart 3x/1min, no
+    time-limit, runs `meshcode hostd run` with auto-update off. Proven model on Samuel's box
+    (.meshcode/hostd-launch.cmd + scheduled task 'MeshCode hostd')."""
+    mc = shutil.which("meshcode") or "meshcode"
+    STATE_DIR.mkdir(parents=True, exist_ok=True)
+    (STATE_DIR / "logs").mkdir(parents=True, exist_ok=True)
+    launch_cmd = STATE_DIR / "hostd-launch.cmd"
+    launch_cmd.write_text(
+        "@echo off\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",
+    )
+    # Register-ScheduledTask (PowerShell) for fidelity: hidden + restart + unlimited + at-logon.
+    ps = (
+        '$a = New-ScheduledTaskAction -Execute "cmd.exe" -Argument \'/c "' + str(launch_cmd) + '"\';'
+        '$t = New-ScheduledTaskTrigger -AtLogOn;'
+        '$s = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries'
+        ' -ExecutionTimeLimit ([TimeSpan]::Zero) -RestartCount 3'
+        ' -RestartInterval (New-TimeSpan -Minutes 1) -Hidden;'
+        '$p = New-ScheduledTaskPrincipal -UserId $env:USERNAME -LogonType Interactive -RunLevel Limited;'
+        "Register-ScheduledTask -TaskName '" + _HOSTD_TASK_NAME + "' -Action $a -Trigger $t"
+        ' -Settings $s -Principal $p -Force | Out-Null'
+    )
+    r = subprocess.run(["powershell", "-NoProfile", "-Command", ps], capture_output=True, text=True)
+    if r.returncode != 0:
+        print(f"[hostd] Register-ScheduledTask failed: {r.stderr.strip()}", file=sys.stderr)
+        return 1
+    print(f"[hostd] installed Windows Task Scheduler job '{_HOSTD_TASK_NAME}' (at-logon, hidden, restart). launcher: {launch_cmd}")
+    print(f'[hostd] start now:  schtasks /Run /TN "{_HOSTD_TASK_NAME}"')
+    return 0
+
+
+def _hostd_install() -> int:
+    import platform
+    if platform.system() == "Windows":
+        return _hostd_install_windows()
+    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)
+        return 2
+    plist = _hostd_plist_path()
+    plist.parent.mkdir(parents=True, exist_ok=True)
+    plist.write_text(_hostd_plist_xml(), encoding="utf-8")
+    subprocess.run(["launchctl", "unload", str(plist)], capture_output=True, text=True)
+    r = subprocess.run(["launchctl", "load", str(plist)], capture_output=True, text=True)
+    if r.returncode != 0:
+        print(f"[hostd] launchctl load failed: {r.stderr.strip()}", file=sys.stderr)
+        return 1
+    print(f"[hostd] installed (RunAtLoad=false, trigger-start). plist: {plist}")
+    print(f"[hostd] start now:  launchctl kickstart gui/$(id -u)/{_HOSTD_PLIST_LABEL}")
+    return 0
+
+
+def _hostd_uninstall() -> int:
+    if sys.platform == "win32":
+        r = subprocess.run(["schtasks", "/Delete", "/TN", _HOSTD_TASK_NAME, "/F"],
+                           capture_output=True, text=True)
+        if r.returncode != 0 and "cannot find" not in (r.stderr + r.stdout).lower():
+            print(f"[hostd] schtasks /Delete failed: {r.stderr.strip()}", file=sys.stderr)
+            return 1
+        print("[hostd] uninstalled (Windows Task Scheduler)")
+        return 0
+    plist = _hostd_plist_path()
+    if not plist.exists():
+        print("[hostd] not installed")
+        return 0
+    subprocess.run(["launchctl", "unload", str(plist)], capture_output=True, text=True)
+    plist.unlink(missing_ok=True)
+    print("[hostd] uninstalled")
+    return 0
+
+
+def cmd_hostd(args: list) -> int:
+    """Entry point for `meshcode hostd ...`."""
+    if not args or args[0] in ("-h", "--help"):
+        print(__doc__)
+        return 0
+    sub = args[0]
+    host_id = get_host_id()
+    api_key = _api_key()
+
+    if sub == "status":
+        if not api_key:
+            print("[hostd] no api key configured", file=sys.stderr)
+            return 1
+        res = _rpc("mc_agents_needing_respawn",
+                   {"p_api_key": api_key, "p_host_id": host_id, "p_stale_seconds": STALE_SECONDS})
+        print(json.dumps({"host_id": host_id, "needing_respawn": res}, indent=2))
+        return 0
+
+    if sub == "install":
+        return _hostd_install()
+
+    if sub == "uninstall":
+        return _hostd_uninstall()
+
+    if sub == "run":
+        if not api_key:
+            _log("FATAL: no api key — run `meshcode login` (key is read from the keychain)")
+            return 1
+        # Register this host in mc_host_config so the dashboard can list it as a
+        # launch target (Path2 canonical: dashboard -> mc_host_set_agents ->
+        # mc_agents.desired_state='running' -> this daemon polls + spawns).
+        # mc_host_config_set upserts (host_id, owner_user_id) idempotently.
+        _reg = _rpc("mc_host_config_set", {"p_api_key": api_key, "p_host_id": host_id})
+        if _reg and _reg.get("ok"):
+            _log(f"registered host {host_id} in mc_host_config")
+        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")
+        while True:
+            try:
+                relaunched = _do_respawns(api_key, host_id)
+                recycled = _do_recycles(api_key, host_id)
+                if relaunched or recycled:
+                    _log(f"sweep done — {relaunched} respawned, {recycled} recycled")
+            except Exception as e:
+                _log(f"WARN: sweep error: {e}")
+            time.sleep(POLL_INTERVAL_SEC)
+
+    print(f"[hostd] unknown subcommand: {sub}", file=sys.stderr)
+    return 1

{meshcode-2.11.72 → meshcode-2.11.74}/meshcode/protocol_handler.py

@@ -108,10 +108,17 @@ def _spawn_terminal_linux(cmd: str) -> tuple[bool, str]:
 
 def _spawn_terminal_windows(cmd: str) -> tuple[bool, str]:
     """Spawn `cmd` in Windows Terminal (preferred) or cmd.exe."""
-    if shutil.which("wt.exe"):
+    # mesh-core ITEM3: wt.exe is a Store-app shim under %LOCALAPPDATA%\Microsoft\WindowsApps and is
+    # frequently NOT on PATH, so shutil.which misses it — resolve that location explicitly.
+    wt = shutil.which("wt.exe")
+    if not wt:
+        cand = Path(os.environ.get("LOCALAPPDATA", "")) / "Microsoft" / "WindowsApps" / "wt.exe"
+        if cand.exists():
+            wt = str(cand)
+    if wt:
         try:
             # `wt -w 0 nt` opens a new tab in existing window
-            subprocess.Popen(["wt.exe", "-w", "0", "nt", "cmd", "/k", cmd])
+            subprocess.Popen([wt, "-w", "0", "nt", "cmd", "/k", cmd])
             return True, "wt"
         except Exception as e:
             return False, f"wt.exe: {e}"
@@ -155,7 +162,12 @@ def cmd_launch_batch(agent_names: Iterable[str]) -> int:
     mc_bin = shutil.which("meshcode") or "meshcode"
 
     for name in names:
-        cmd = f"{shlex.quote(mc_bin)} run {shlex.quote(name)}"
+        # PER-PLATFORM quoting (mesh-core FIX2): cmd.exe wants double-quotes, not POSIX shlex
+        # single-quotes (cmd.exe passes single-quotes through literally -> file-not-found).
+        if sys.platform == "win32":
+            cmd = f'"{mc_bin}" run "{name}"'
+        else:
+            cmd = f"{shlex.quote(mc_bin)} run {shlex.quote(name)}"
         ok, info = _spawn_terminal(cmd)
         if ok:
             launched.append(name)