meshcode 2.11.150__tar.gz → 2.11.153__tar.gz

{meshcode-2.11.150 → meshcode-2.11.153}/PKG-INFO

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

{meshcode-2.11.150 → meshcode-2.11.153}/meshcode/__init__.py

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

{meshcode-2.11.150 → meshcode-2.11.153}/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.150 → meshcode-2.11.153}/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.150 → meshcode-2.11.153}/meshcode/protocol_handler.py

@@ -272,30 +272,53 @@ def _tmux(tmux: str, *args: str) -> subprocess.CompletedProcess:
     return subprocess.run([tmux, *args], capture_output=True, text=True, timeout=15)
 
 
-def _fleet_wrap(cmd: str) -> str:
+def _fleet_wrap(cmd: str, tmux: str = "tmux") -> str:
     """Shell line for an agent inside its tmux window.
 
-    Drop the LAST `exec ` (same trick as the .command launcher) so the shell
-    survives the agent's exit and can translate rc 143 (SIGTERM = hostd
-    stop/ghost-kill, task 91201315: that's the job FINISHING) to 0 — otherwise
-    `remain-on-exit failed` would keep a dead pane for every plain Stop.
-
-    CLOSE-TAB=STOP (task 4df5a126, Samuel 68b1c17b: "cierro su terminal y
-    ya"): export MESHCODE_CLOSE_STOP_SIGHUP=1 so the MCP server's gated POSIX
-    close=stop handler (b6da0d54, default OFF) arms INSIDE fleet tabs only.
-    In a tmux pane SIGHUP is unambiguous — only kill-window / kill-session /
-    tmux-server death close the pty (a window-close of the shared Terminal
-    just DETACHES; ESC never closes the pty) — so the false-stop risk that
-    kept the flag off for plain windows (task dfa17461) does not exist here.
-    Right-click a tab -> Kill => SIGHUP => agent flips desired_state=stopped
-    server-side and exits clean: offline, NO hostd ghost-respawn (mig 494
-    coherent). A real crash never runs the handler => crash-respawn intact."""
+    RAII / opener-owns-teardown (Samuel P0 'vergo de terminales' — professional
+    supervisor pattern, NOT a patch): this wrapper OWNS its tmux window and an
+    EXIT+signal trap closes THAT window whenever the agent process dies — clean
+    stop, recycle-exit, OR crash — so a dead pane never lingers and accumulates
+    (459 spawns vs 0 closes / 18 days -> ~50 stale tabs). It self-targets via
+    $TMUX_PANE, so it can only EVER close its OWN window — never a live sibling's
+    (the 'never close a live agent' guardrail is structural here: the trap fires
+    only when THIS agent already exited). Replaces the old
+    `remain-on-exit=failed keeps the dead pane for debugging` behavior, which was
+    the accumulation source. rc 143 (SIGTERM = clean hostd stop, task 91201315)
+    and clean exits close silently; a crash rc is logged to stderr first.
+
+    Kill-switch env MESHCODE_FLEET_WINDOW_CLOSE: `0`/`off` restores the old
+    keep-dead-tab-for-debugging behavior; `dry`/`dryrun` logs intent without
+    closing.
+
+    Drops the LAST `exec ` (same trick as the .command launcher) so the shell
+    SURVIVES the agent's exit and the trap can run. CLOSE-TAB=STOP (task
+    4df5a126, Samuel 68b1c17b): export MESHCODE_CLOSE_STOP_SIGHUP=1 so the MCP
+    server's gated POSIX close=stop handler arms INSIDE fleet tabs (right-click
+    tab -> Kill => SIGHUP => agent flips desired_state=stopped + exits clean, no
+    hostd ghost-respawn). A real crash still respawns (hostd, DB-driven) —
+    closing the crashed tab just means the respawn opens a fresh one."""
     if "exec " in cmd:
         head, _, tail = cmd.rpartition("exec ")
         cmd = head + tail
-    return (f'export MESHCODE_CLOSE_STOP_SIGHUP=1; '
-            f'{cmd}; MC_RC=$?; if [ "$MC_RC" = "143" ]; then exit 0; fi; '
-            f'echo "[meshcode] agent exited rc=$MC_RC — tab kept for debugging"; exit $MC_RC')
+    tq = shlex.quote(tmux)
+    return (
+        'export MESHCODE_CLOSE_STOP_SIGHUP=1; '
+        # RAII teardown: close OUR OWN tmux window on ANY exit/signal. $TMUX_PANE
+        # is set by tmux for the pane we run in, so kill-window can only ever hit
+        # THIS window. Disarm traps first (avoid double-run via the EXIT trap).
+        '_mc_close() { _rc=$?; trap - EXIT INT TERM HUP; '
+        'case "${MESHCODE_FLEET_WINDOW_CLOSE:-}" in '
+        '0|off|false|no) exit "$_rc";; '
+        'dry|dryrun|dry-run) echo "[meshcode] DRY-RUN: would close own tab (rc=$_rc)" >&2; exit "$_rc";; '
+        'esac; '
+        '{ [ "$_rc" != "0" ] && [ "$_rc" != "143" ]; } && '
+        'echo "[meshcode] agent exited rc=$_rc — closing tab (1 agent = 1 terminal)" >&2; '
+        f'{tq} kill-window -t "${{TMUX_PANE:-}}" 2>/dev/null; '
+        'exit "$_rc"; }; '
+        'trap _mc_close EXIT INT TERM HUP; '
+        f'{cmd}'
+    )
 
 
 def _fleet_attach_macos(tmux: str) -> tuple[bool, str]:
@@ -360,7 +383,7 @@ def _spawn_fleet_tab(cmd: str) -> tuple[bool, str]:
     if not tmux:
         return False, "tmux not installed (brew install tmux -> tabbed fleet window)"
     label = _fleet_tab_name(cmd)
-    wrapped = _fleet_wrap(cmd)
+    wrapped = _fleet_wrap(cmd, tmux)
     try:
         fresh_session = _tmux(tmux, "has-session", "-t", f"={_FLEET_SESSION}").returncode != 0
         win_id = ""
@@ -684,10 +707,20 @@ def _write_fleet_native_agent(cmd: str) -> Path:
         "disown",
         run_line,
         "MC_RC=$?",
-        # clean exit (0, or 143 = hostd stop sweep): close ONLY this tab.
-        # Crash: keep tab + scrollback (debugging > clean window).
-        'if { [ "$MC_RC" = "0" ] || [ "$MC_RC" = "143" ]; } && [ -n "$MC_TTY" ]; then',
-        "  /usr/bin/osascript"
+        # RAII / opener-owns-teardown (Samuel P0 'vergo de terminales' —
+        # professional pattern): close OUR OWN native tab on ANY exit — clean
+        # stop, recycle-exit, OR crash — so a dead tab never accumulates (Ian's
+        # ~40 stale native tabs). The osascript self-targets by MC_TTY (closes
+        # ONLY the tab whose tty is ours) so a LIVE sibling is never touched.
+        # Replaces the old keep-crashed-tab-for-debugging behavior. Kill-switch
+        # MESHCODE_FLEET_WINDOW_CLOSE=0 restores it; =dry logs intent.
+        'case "${MESHCODE_FLEET_WINDOW_CLOSE:-}" in',
+        '  0|off|false|no) { [ "$MC_RC" != "0" ] && [ "$MC_RC" != "143" ]; } && echo "[meshcode] agent exited rc=$MC_RC — tab kept (close disabled)" ;;',
+        '  dry|dryrun|dry-run) echo "[meshcode] DRY-RUN: would close own tab (rc=$MC_RC)" ;;',
+        '  *)',
+        '    { [ "$MC_RC" != "0" ] && [ "$MC_RC" != "143" ]; } && echo "[meshcode] agent exited rc=$MC_RC — closing tab (1 agent = 1 terminal)"',
+        '    if [ -n "$MC_TTY" ]; then',
+        "      /usr/bin/osascript"
         " -e 'on run argv'"
         " -e 'tell application \"Terminal\"'"
         " -e 'repeat with w in windows'"
@@ -699,9 +732,9 @@ def _write_fleet_native_agent(cmd: str) -> Path:
         " -e 'end repeat'"
         " -e 'end tell'"
         " -e 'end run' \"$MC_TTY\" >/dev/null 2>&1",
-        "else",
-        '  echo "[meshcode] agent exited rc=$MC_RC — tab kept for debugging"',
-        "fi",
+        '    fi',
+        '    ;;',
+        'esac',
     ]
     p["dir"].mkdir(parents=True, exist_ok=True)
     script_path.write_text("\n".join(lines) + "\n", encoding="utf-8")

{meshcode-2.11.150 → meshcode-2.11.153}/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.150 → meshcode-2.11.153}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.150 → meshcode-2.11.153}/pyproject.toml

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