meshcode 2.11.149__tar.gz → 2.11.152__tar.gz

{meshcode-2.11.149 → meshcode-2.11.152}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: meshcode
-Version: 2.11.149
+Version: 2.11.152
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT
@@ -18,8 +18,17 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+Requires-Dist: mcp[cli]>=1.0.0
+Requires-Dist: websockets>=12.0
+Requires-Dist: realtime>=2.0.0
+Requires-Dist: keyring>=24.0
+Requires-Dist: cryptography>=41.0
 Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
 Provides-Extra: dev
+Requires-Dist: build>=1.0; extra == "dev"
+Requires-Dist: twine>=4; extra == "dev"
+Requires-Dist: pytest>=8; extra == "dev"
 
 # MeshCode
 

{meshcode-2.11.149 → meshcode-2.11.152}/meshcode/__init__.py

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

{meshcode-2.11.149 → meshcode-2.11.152}/meshcode/comms_v4.py

@@ -319,8 +319,28 @@ def get_project_id(project_name):
     if rows:
         return rows[0]["id"]
 
-    # Last resort: try to create. Will fail under RLS for unauthenticated
-    # contexts, but kept for legacy callers + admin tooling.
+    # ZERO-FRICTION onboarding (R3): the project doesn't exist yet — create it
+    # for the authenticated user via the same RPC the MCP tool uses, then
+    # re-resolve to get its id. Makes `meshcode go <agent> --project <new>`
+    # just work right after `meshcode init` (no dashboard round-trip).
+    if api_key:
+        try:
+            cr = sb_rpc("mc_create_meshwork_by_api_key", {
+                "p_api_key": api_key, "p_name": project_name,
+            })
+            if isinstance(cr, dict) and (cr.get("ok") or cr.get("project_id")):
+                r2 = sb_rpc("mc_resolve_project", {
+                    "p_api_key": api_key, "p_project_name": project_name,
+                })
+                if isinstance(r2, dict) and r2.get("project_id"):
+                    return r2["project_id"]
+                if isinstance(cr.get("project_id"), str):
+                    return cr["project_id"]
+        except Exception:
+            pass
+
+    # Last resort: legacy anon insert (fails under RLS for owned projects;
+    # kept for very old test scripts / admin tooling).
     result = sb_insert("mc_projects", {"name": project_name})
     if result and len(result) > 0:
         return result[0]["id"]
@@ -2426,6 +2446,14 @@ def login(api_key):
     except Exception:
         pass
 
+    # ZERO-FRICTION onboarding (R1): auto-install Claude Code so `pip install
+    # meshcode` + `meshcode login` is enough — no separate manual editor install.
+    try:
+        from meshcode.doctor import ensure_claude_installed
+        ensure_claude_installed(verbose=True)
+    except Exception:
+        pass
+
     return True
 
 
@@ -2822,7 +2850,8 @@ if __name__ == "__main__":
         if not _has_creds:
             print()
             print("  Welcome to MeshCode!")
-            print("  First time? Run: meshcode quickstart")
+            print("  First time? Run: meshcode init")
+            print("    ↳ opens your browser to approve — no API key to copy/paste")
             print("  Already have an API key? Run: meshcode login <api_key>")
             print("  Need help? Run: meshcode doctor")
             print()
@@ -2914,6 +2943,15 @@ if __name__ == "__main__":
         print("  " + "=" * 40)
         print()
 
+        # ZERO-FRICTION onboarding (R1): auto-install Claude Code BEFORE the
+        # pre-flight so a brand-new machine (no claude) self-heals and PASSES
+        # doctor instead of hard-blocking onboarding.
+        try:
+            from meshcode.doctor import ensure_claude_installed
+            ensure_claude_installed(verbose=True)
+        except Exception:
+            pass
+
         # B2 pre-flight: refuse to onboard if env is broken
         from meshcode.doctor import run_doctor
         if run_doctor(skip_api_key_check=True) != 0:

{meshcode-2.11.149 → meshcode-2.11.152}/meshcode/doctor.py

@@ -17,7 +17,7 @@ import shutil
 import subprocess
 import urllib.request
 import urllib.error
-from typing import List, Tuple
+from typing import List, Optional, Tuple
 
 Status = Tuple[str, str, str]
 
@@ -97,6 +97,106 @@ def _check_claude() -> Status:
     )
 
 
+def _resolve_claude() -> Optional[str]:
+    """Return a path to the `claude` binary — via PATH, or common global-bin
+    locations a fresh `npm i -g` / claude.ai install lands in but that aren't
+    on this process's PATH yet (qa cold-start finding: macOS/Linux had no
+    fallback, only Windows did). None if not found."""
+    p = shutil.which("claude")
+    if p:
+        return p
+    if sys.platform == "win32":
+        appdata = os.environ.get("APPDATA", "")
+        local = os.environ.get("LOCALAPPDATA", "")
+        cands = [
+            os.path.join(appdata, "npm", "claude.cmd"),
+            os.path.join(appdata, "npm", "claude"),
+            os.path.join(local, "Programs", "claude", "claude.exe"),
+        ]
+    else:
+        home = os.path.expanduser("~")
+        cands = [
+            os.path.join(home, ".local", "bin", "claude"),
+            "/opt/homebrew/bin/claude",
+            "/usr/local/bin/claude",
+            os.path.join(home, ".npm-global", "bin", "claude"),
+        ]
+    for c in cands:
+        if c and os.path.isfile(c):
+            return c
+    # Ask npm where global packages live and check its bin dir.
+    try:
+        if sys.platform == "win32":
+            base = os.path.dirname(subprocess.check_output(
+                ["npm", "root", "-g"], text=True, timeout=5).strip())
+            names = ("claude.cmd", "claude.exe", "claude")
+        else:
+            base = os.path.join(subprocess.check_output(
+                ["npm", "prefix", "-g"], text=True, timeout=5).strip(), "bin")
+            names = ("claude",)
+        for n in names:
+            cp = os.path.join(base, n)
+            if os.path.isfile(cp):
+                return cp
+    except Exception:
+        pass
+    return None
+
+
+def ensure_claude_installed(verbose: bool = False) -> bool:
+    """ZERO-FRICTION onboarding (R1): best-effort auto-install of the Claude
+    Code CLI so getting started is just `pip install meshcode` + `meshcode
+    init` / `meshcode login` — no separate manual editor install. Mirrors the
+    hostd._hostd_bootstrap pattern (best-effort, idempotent, NEVER raises —
+    auth/onboarding must not fail on a hiccup). Cross-platform: macOS / Linux /
+    Windows (qa finding — cover mac/linux so a cold machine doesn't break).
+
+    Returns True if `claude` is present (already, or after a successful
+    install), False if it's still missing (caller falls back to the manual
+    hint / doctor still reports it).
+    """
+    if _resolve_claude():
+        return True
+    npm = shutil.which("npm")
+    if npm:
+        if verbose:
+            print("[meshcode] Claude Code not found — installing "
+                  "(npm i -g @anthropic-ai/claude-code)...")
+        try:
+            r = subprocess.run(
+                [npm, "install", "-g", "@anthropic-ai/claude-code"],
+                capture_output=True, text=True, timeout=300,
+            )
+            found = _resolve_claude()
+            if found:
+                # Make the freshly-installed claude visible to the REST of this
+                # process (the login/init flow) even if npm's global bin isn't
+                # on PATH yet. The later `meshcode run` is a separate process and
+                # resolves independently via _detect_editor's own fallback.
+                try:
+                    bdir = os.path.dirname(found)
+                    parts = os.environ.get("PATH", "").split(os.pathsep)
+                    if bdir and bdir not in parts:
+                        os.environ["PATH"] = bdir + os.pathsep + os.environ.get("PATH", "")
+                except Exception:
+                    pass
+                if verbose:
+                    print("[meshcode]   Claude Code installed.")
+                return True
+            if verbose:
+                tail = (r.stderr or r.stdout or "").strip().splitlines()
+                print("[meshcode]   Claude Code install did not complete"
+                      + (f": {tail[-1]}" if tail else "."))
+        except Exception as e:
+            if verbose:
+                print(f"[meshcode]   Claude Code auto-install skipped: {e}")
+    if verbose:
+        print("[meshcode] Claude Code is required. Install it with one of:")
+        print("[meshcode]   npm i -g @anthropic-ai/claude-code      (needs Node.js)")
+        print("[meshcode]   or visit https://claude.ai/install")
+    return False
+
+
 def _check_node() -> Status:
     needs_node = False
     try:

{meshcode-2.11.149 → meshcode-2.11.152}/meshcode/hostd.py

@@ -2822,7 +2822,12 @@ def _hostd_install_windows() -> int:
         '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',
+        # F1a (task 48c3f294): launch the SUPERVISOR, not `hostd run` directly.
+        # The supervisor owns + revives hostd on CRASH — the recovery the HKCU\Run
+        # tier (login-only) lacks (that was the dead launch button on Samuel's box).
+        # It self-singletons, so the Task-Scheduler periodic watchdog tier above
+        # can also point here without ever double-starting.
+        f'"{mc}" hostd supervise\r\n',
         encoding="utf-8",
     )
     # Register-ScheduledTask (PowerShell) — ROBUST KEEP-ALIVE (task 843f282c CRITICAL: hostd died ~15:04
@@ -3135,6 +3140,163 @@ def _acquire_hostd_singleton():
         return (None, "error")
 
 
+# ------------------------------------------------------------------
+# hostd SUPERVISOR (task 48c3f294 / F1a — Windows crash+reboot revive). The only
+# non-admin Windows persistence that works on locked-down boxes (Samuel's) is
+# HKCU\Run, which fires ONLY at login: a hostd that CRASHES mid-session is never
+# revived = the dead launch button. This supervisor is a SEPARATE, minimal
+# process that OWNS a `hostd run` child and restarts it on exit — the crash
+# recovery HKCU\Run lacks. Separate process, NOT hostd self-forking: an early
+# hostd crash (import error / startup fault) before any in-process fork would
+# otherwise never be revived. COMPOSES with hostd's in-process wedge watchdog
+# (process-STUCK self-restart via execv); this is the process-GONE half.
+# Anti-storm: the restart loop mirrors the absolute respawn cap (5618ac17) — a
+# hostd that crash-loops WITHOUT ever staying up is STOPPED after a ceiling and
+# its status written to hostd-supervisor.state, so the supervisor can never
+# become the storm it guards against. macOS (launchd KeepAlive) + Linux (systemd
+# Restart=on-failure) already get crash-revive, so this is win32-only in practice.
+# ------------------------------------------------------------------
+_SUP_LOCK_FH = None
+_SUP_STATE_PATH = STATE_DIR / "hostd-supervisor.state"
+_SUP_CONFIRMED_BOOT_S = _env_int("MESHCODE_SUP_CONFIRMED_BOOT_SEC", 120, 30)  # child up >= this = confirmed boot -> reset cap
+_SUP_ABS_CAP          = _env_int("MESHCODE_SUP_ABS_CAP", 5, 2)                # crash-restarts w/o confirmed boot before STOP
+_SUP_ABS_WINDOW_S     = _env_int("MESHCODE_SUP_ABS_WINDOW_SEC", 3600, 300)    # rolling window
+_SUP_BACKOFF_BASE_S   = _env_int("MESHCODE_SUP_BACKOFF_BASE_SEC", 5, 1)       # exp backoff base between crash restarts
+_SUP_BACKOFF_MAX_S    = _env_int("MESHCODE_SUP_BACKOFF_MAX_SEC", 300, 10)     # backoff ceiling
+_SUP_POLL_S           = _env_int("MESHCODE_SUP_POLL_SEC", 5, 1)               # poll cadence while a hostd is already alive
+
+
+def _flock_probe_held(lock_path: Path) -> bool:
+    """True if a LIVE process holds an exclusive flock/msvcrt lock on lock_path.
+    Non-destructive try-acquire-release — robust vs the informational pid inside
+    the lock file (which can be stale after a hard kill). Used to detect a live
+    hostd before the supervisor spawns one (never double-start)."""
+    try:
+        fh = open(lock_path, "a+")
+    except Exception:
+        return False  # can't evaluate -> assume free (supervisor errs toward having a hostd)
+    try:
+        if sys.platform == "win32":
+            import msvcrt
+            fh.seek(0)
+            try:
+                msvcrt.locking(fh.fileno(), msvcrt.LK_NBLCK, 1)
+            except OSError:
+                return True  # held by a live process
+            try:
+                msvcrt.locking(fh.fileno(), msvcrt.LK_UNLCK, 1)
+            except OSError:
+                pass
+            return False
+        import fcntl
+        try:
+            fcntl.flock(fh.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except OSError:
+            return True
+        fcntl.flock(fh.fileno(), fcntl.LOCK_UN)
+        return False
+    finally:
+        fh.close()
+
+
+def _acquire_supervisor_singleton():
+    """One supervisor per machine — flock/msvcrt on hostd-supervisor.lock, held
+    for the process lifetime, OS-released on ANY death (no stale-lock problem;
+    same field-tested mechanism as _acquire_hostd_singleton — addresses the
+    SPOC's 'O_EXCL leaves a stale lock after a hard kill' note). Returns the fh
+    on success, None if another live supervisor already holds it."""
+    try:
+        STATE_DIR.mkdir(parents=True, exist_ok=True)
+        fh = open(STATE_DIR / "hostd-supervisor.lock", "a+")
+    except Exception:
+        return None
+    try:
+        if sys.platform == "win32":
+            import msvcrt
+            fh.seek(0)
+            msvcrt.locking(fh.fileno(), msvcrt.LK_NBLCK, 1)
+        else:
+            import fcntl
+            fcntl.flock(fh.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+    except OSError:
+        fh.close()
+        return None
+    try:
+        fh.seek(0)
+        fh.truncate()
+        fh.write(str(os.getpid()))
+        fh.flush()
+    except Exception:
+        pass
+    return fh
+
+
+def _sup_write_state(state: str, reason: str = "", restart_count: int = 0) -> None:
+    """Persist supervisor status to hostd-supervisor.state — the data source for
+    the F1b dashboard-liveness UX (FE reads it to surface 'hostd stopped/looping'
+    instead of a silently dead daemon). Best-effort."""
+    try:
+        _SUP_STATE_PATH.write_text(json.dumps({
+            "state": state, "reason": reason, "restart_count": restart_count,
+            "pid": os.getpid(), "ts": int(time.time()),
+        }), encoding="utf-8")
+    except Exception:
+        pass
+
+
+def _hostd_supervise() -> int:
+    """Supervisor loop: own a `hostd run` child and revive it on crash, with an
+    absolute no-confirmed-boot cap so a crash-loop can't storm. See the block
+    comment above for the full rationale."""
+    fh = _acquire_supervisor_singleton()
+    if fh is None:
+        _log("hostd supervisor already running (hostd-supervisor.lock held) — exiting (singleton)")
+        return 0
+    global _SUP_LOCK_FH
+    _SUP_LOCK_FH = fh
+    _log("hostd supervisor started — owning + reviving `hostd run` (F1a)")
+    argv = _hostd_run_argv()
+    restarts: list = []  # spawn timestamps that did NOT reach a confirmed boot
+    while True:
+        # NEVER double-start: if a live hostd already holds hostd.lock (a manual
+        # `hostd run`, or an orphan that outlived a prior supervisor), don't spawn
+        # — wait for it to free. Without this, hostd's own singleton would make
+        # our child exit 0 instantly and we'd read that as a crash and loop.
+        if _flock_probe_held(STATE_DIR / "hostd.lock"):
+            _sup_write_state("running", "hostd_already_live", len(restarts))
+            time.sleep(_SUP_POLL_S)
+            continue
+        now = time.time()
+        restarts = [t for t in restarts if now - t < _SUP_ABS_WINDOW_S]
+        if len(restarts) >= _SUP_ABS_CAP:
+            _sup_write_state("stopped", "abs_cap_crash_loop", len(restarts))
+            _log(f"SUPERVISOR ABS-CAP: hostd crash-looped {len(restarts)}x in <= {_SUP_ABS_WINDOW_S}s "
+                 f"without staying up >= {_SUP_CONFIRMED_BOOT_S}s — STOPPING (a fresh `meshcode hostd "
+                 f"install` re-arms). Wrote {_SUP_STATE_PATH.name} for the dashboard.")
+            return 0
+        start = time.time()
+        restarts.append(start)
+        _sup_write_state("running", "spawning_hostd", len(restarts))
+        try:
+            proc = subprocess.Popen(argv, stdin=subprocess.DEVNULL)
+        except Exception as e:
+            backoff = min(_SUP_BACKOFF_MAX_S, _SUP_BACKOFF_BASE_S * (2 ** (len(restarts) - 1)))
+            _log(f"supervisor: failed to spawn hostd ({e}) — retry in {backoff}s")
+            time.sleep(backoff)
+            continue
+        rc = proc.wait()  # authoritative: the hostd process is GONE
+        uptime = time.time() - start
+        if uptime >= _SUP_CONFIRMED_BOOT_S:
+            restarts = []  # stayed up long enough = confirmed boot -> reset the cap
+            backoff = _SUP_BACKOFF_BASE_S
+            _log(f"hostd exited rc={rc} after {int(uptime)}s (confirmed boot) — restart in {backoff}s")
+        else:
+            backoff = min(_SUP_BACKOFF_MAX_S, _SUP_BACKOFF_BASE_S * (2 ** (len(restarts) - 1)))
+            _log(f"hostd exited rc={rc} after {int(uptime)}s (no confirmed boot, "
+                 f"{len(restarts)}/{_SUP_ABS_CAP}) — restart in {backoff}s")
+        time.sleep(backoff)
+
+
 def cmd_hostd(args: list) -> int:
     """Entry point for `meshcode hostd ...`."""
     if not args or args[0] in ("-h", "--help"):
@@ -3159,6 +3321,12 @@ def cmd_hostd(args: list) -> int:
     if sub == "uninstall":
         return _hostd_uninstall()
 
+    if sub == "supervise":
+        # F1a (task 48c3f294): own + revive `hostd run`. The Windows non-admin
+        # autostart (HKCU\Run) points here so a mid-session hostd CRASH is revived,
+        # not just a login. Not for macOS/Linux (launchd/systemd already revive).
+        return _hostd_supervise()
+
     if sub == "run":
         if not api_key:
             _log("FATAL: no api key — run `meshcode login` (key is read from the keychain)")

{meshcode-2.11.149 → meshcode-2.11.152}/meshcode/run_agent.py

@@ -34,7 +34,7 @@ REGISTRY_PATH = WORKSPACES_ROOT / ".registry.json"
 
 # Samuel directive 2026-06-17: all agents boot with the best model by default.
 # Overrides (settings.json "model" or mc_agent_model_pref RPC) still respected.
-PLATFORM_DEFAULT_MODEL = "opus"
+PLATFORM_DEFAULT_MODEL = "claude-opus-4-8"
 
 
 def _pretrust_claude_workspace(*paths) -> None:
@@ -769,6 +769,29 @@ def _detect_editor() -> Optional[str]:
         except Exception:
             pass
 
+    # macOS/Linux fallback: a freshly `npm i -g` claude (or claude.ai installer)
+    # may not be on this process's PATH yet (GUI launch / stale shell) — qa
+    # cold-start finding: posix had no fallback, only Windows did. Check common
+    # global-bin locations + ask npm for its global prefix.
+    if sys.platform != "win32":
+        home = os.path.expanduser("~")
+        posix_candidates = [
+            os.path.join(home, ".local", "bin", "claude"),
+            "/opt/homebrew/bin/claude",
+            "/usr/local/bin/claude",
+            os.path.join(home, ".npm-global", "bin", "claude"),
+        ]
+        for c in posix_candidates:
+            if c and os.path.isfile(c):
+                return c
+        try:
+            prefix = subprocess.check_output(["npm", "prefix", "-g"], text=True, timeout=5).strip()
+            p = os.path.join(prefix, "bin", "claude")
+            if os.path.isfile(p):
+                return p
+        except Exception:
+            pass
+
     return None
 
 

{meshcode-2.11.149 → meshcode-2.11.152}/meshcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: meshcode
-Version: 2.11.149
+Version: 2.11.152
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT
@@ -18,8 +18,17 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+Requires-Dist: mcp[cli]>=1.0.0
+Requires-Dist: websockets>=12.0
+Requires-Dist: realtime>=2.0.0
+Requires-Dist: keyring>=24.0
+Requires-Dist: cryptography>=41.0
 Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
 Provides-Extra: dev
+Requires-Dist: build>=1.0; extra == "dev"
+Requires-Dist: twine>=4; extra == "dev"
+Requires-Dist: pytest>=8; extra == "dev"
 
 # MeshCode
 

{meshcode-2.11.149 → meshcode-2.11.152}/pyproject.toml

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