meshcode 2.11.154__tar.gz → 2.11.155__tar.gz

{meshcode-2.11.154 → meshcode-2.11.155}/PKG-INFO

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

{meshcode-2.11.154 → meshcode-2.11.155}/meshcode/__init__.py

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

{meshcode-2.11.154 → meshcode-2.11.155}/meshcode/run_agent.py

@@ -933,11 +933,18 @@ def _preflight_hb_enabled() -> bool:
     return os.environ.get("MESHCODE_HOSTD_SPAWN") != "1"
 
 
-def _report_launch_failure(agent: str, project: str, reason: str, detail: str) -> None:
+def _report_launch_failure(agent: str, project: str, reason: str, detail: str,
+                           status: str = "offline") -> None:
     """Editor spawn failed AFTER the pre-flight heartbeat already marked the
     agent online — revert the ghost 'online' row to offline and tell the
     dashboard WHY (launch-reliability fix 809d3b37, factors C + H).
 
+    `status` (must be a valid mc_agents.status per valid_agent_status): default
+    'offline' reverts a ghost-online editor-spawn failure. The replica
+    workspace-provisioning failure (task 9698d738) passes 'needs_setup' — the
+    failure IS an unprovisioned workspace, so the dashboard CTA matches the fix
+    (`meshcode setup <proj> <agent>`). 'error' is NOT a valid status.
+
     This replaces a broken inline block in run()'s FileNotFoundError handler
     that referenced `api_key`/`project_id` — names that are never bound in
     run()'s scope — so the very RPC meant to surface "claude not installed"
@@ -987,12 +994,13 @@ def _report_launch_failure(agent: str, project: str, reason: str, detail: str) -
         except Exception:
             pass
 
-        # 2) Revert the ghost 'online' the pre-flight heartbeat stamped (factor C).
+        # 2) Set the failure status (default 'offline' reverts the pre-flight ghost;
+        #    'needs_setup' for an unprovisioned replica workspace — factor C).
         status_body = json.dumps({
             "p_api_key": api_key,
             "p_project_id": project_id,
             "p_agent_name": agent,
-            "p_status": "offline",
+            "p_status": status,
             "p_task": f"launch failed: {reason}",
         })
         status_req = Request(
@@ -1005,6 +1013,49 @@ def _report_launch_failure(agent: str, project: str, reason: str, detail: str) -
         print(f"[meshcode]   Launch-failure report skipped: {e}", file=sys.stderr)
 
 
+def _provision_replica_mcp_from_base(project: str, agent: str, ws: "Path") -> bool:
+    """BLINDAJE (task 9698d738 / Samuel P0 "réplicas prenden pero no bootean"):
+    provision a replica's .mcp.json by cloning the BASE agent's known-good one when a
+    fresh setup_workspace() fails (e.g. the keychain is unreadable non-interactively at
+    hostd spawn -> setup_workspace returns 2 -> run_agent used to `return 2` and DIE
+    before the MCP server even started: instance_id NULL, heartbeat NEVER, never ran the
+    lease = "prende pero no bootea").
+
+    A replica named '<base>-<N>' is the same user's clone, so the base's MCP server
+    block (api key / project_id / keychain profile baked at its last setup) is valid for
+    it. We copy it, swap ONLY the server id + MESHCODE_AGENT, and write it to the replica
+    workspace. The base workspace exists whenever the base agent booted (the common
+    case — and the empirically healthy replicas all had a pre-existing workspace).
+    Returns True iff a .mcp.json was written. Never raises."""
+    try:
+        import re as _re
+        m = _re.match(r"^(?P<base>.+)-(?P<n>\d+)$", agent)
+        if not m:
+            return False  # not a '<base>-<N>' replica name — nothing to clone
+        base = m.group("base")
+        base_mcp = WORKSPACES_ROOT / f"{project}-{base}" / ".mcp.json"
+        if not base_mcp.exists():
+            return False
+        doc = json.loads(base_mcp.read_text(encoding="utf-8"))
+        servers = doc.get("mcpServers") or {}
+        if not servers:
+            return False
+        # base workspaces hold exactly one server block
+        _base_id, block = next(iter(servers.items()))
+        block = json.loads(json.dumps(block))  # deep copy so we don't mutate the source
+        env = block.get("env")
+        if isinstance(env, dict):
+            env["MESHCODE_AGENT"] = agent  # the only identity that differs from the base
+        new_id = f"meshcode-{project}-{agent}"
+        ws.mkdir(parents=True, exist_ok=True)
+        (ws / ".mcp.json").write_text(
+            json.dumps({"mcpServers": {new_id: block}}, indent=2) + "\n", encoding="utf-8")
+        return (ws / ".mcp.json").exists()
+    except Exception as e:
+        print(f"[meshcode]   replica base-fallback .mcp.json failed: {e}", file=sys.stderr)
+        return False
+
+
 # Repo-scoped launch (task 24e3dd44 / core-commander launch-diff). When `meshcode run
 # <agent> --repo <path>` is used, the agent boots with cwd=repo (not the meshcode
 # workspace), so its repo CLAUDE.md loads — we carry the boot protocol via
@@ -1293,19 +1344,44 @@ def run(agent: str, project: Optional[str] = None, editor_override: Optional[str
     if not mcp_json_path.exists():
         # Regenerate via setup_workspace (has all data it needs from server)
         print(f"[meshcode] .mcp.json missing from workspace — regenerating...", file=sys.stderr)
+        _regen_ok = False
+        _regen_err = ""
         try:
             from .setup_clients import setup_workspace
             rc = setup_workspace(resolved_project, agent,
                                  keychain_profile=_preferred_keychain_profile(resolved_project, agent))
-            if rc == 0 and mcp_json_path.exists():
+            _regen_ok = (rc == 0 and mcp_json_path.exists())
+            if _regen_ok:
                 print(f"[meshcode] .mcp.json regenerated successfully.", file=sys.stderr)
             else:
-                print(f"[meshcode] ERROR: could not regenerate .mcp.json.", file=sys.stderr)
-                print(f"[meshcode]        Run `meshcode setup {resolved_project} {agent}` manually.", file=sys.stderr)
-                return 2
+                _regen_err = f"setup_workspace rc={rc}"
+                print(f"[meshcode] ERROR: could not regenerate .mcp.json ({_regen_err}).", file=sys.stderr)
         except Exception as e:
+            _regen_err = repr(e)
             print(f"[meshcode] ERROR: .mcp.json missing and regeneration failed: {e}", file=sys.stderr)
-            print(f"[meshcode]        Run `meshcode setup {resolved_project} {agent}` to fix.", file=sys.stderr)
+
+        # BLINDAJE 1 (task 9698d738): replica base-workspace fallback. A replica whose
+        # workspace was never provisioned hits this path; if setup_workspace fails (e.g.
+        # keychain unreadable non-interactively at spawn) the process used to `return 2`
+        # and DIE pre-boot ("prende pero no bootea"). Clone the base agent's known-good
+        # .mcp.json so the replica boots anyway.
+        if not _regen_ok and _provision_replica_mcp_from_base(resolved_project, agent, ws) \
+                and mcp_json_path.exists():
+            print(f"[meshcode] .mcp.json provisioned from base agent (replica fallback, "
+                  f"task 9698d738).", file=sys.stderr)
+            _regen_ok = True
+
+        # BLINDAJE 2 (task 9698d738): never die SILENT. If we still can't provision,
+        # report the launch as FAILED (mc_resolve_launch status='failed' + status row)
+        # so the dashboard shows WHY instead of a phantom 'spawned but offline' replica.
+        if not _regen_ok:
+            _report_launch_failure(
+                agent, resolved_project,
+                "workspace .mcp.json could not be provisioned",
+                f"setup_workspace failed ({_regen_err or 'unknown'}) and no base "
+                f"workspace to clone — run `meshcode setup {resolved_project} {agent}`",
+                status="needs_setup")
+            print(f"[meshcode]        Run `meshcode setup {resolved_project} {agent}` manually.", file=sys.stderr)
             return 2
 
     # R2-5 (2.11.117) boot-always-latest: resolve target version (explicit pin
@@ -1672,10 +1748,24 @@ def run(agent: str, project: Optional[str] = None, editor_override: Optional[str
             cmd += [
                 "--mcp-config", str(mcp_json_path),
                 "--settings", str(ws / ".claude" / "settings.json"),
-                "--append-system-prompt", MESHCODE_BOOT_PROTOCOL.format(
-                    agent=agent, project=resolved_project,
-                    role=(agent_role or "MCP-connected agent"), repo=repo_lock),
             ]
+        # Boot protocol — ALWAYS injected (task 9698d738 / Samuel P0 "réplicas prenden
+        # pero NO bootean en TODAS las meshes"). It was gated on repo_lock on the
+        # assumption that non-repo launches load the protocol from the workspace
+        # CLAUDE.md at cwd=ws. But hostd-spawned REPLICAS frequently have NO provisioned
+        # ws/CLAUDE.md (mc_replicate_agent creates the DB row, not the disk workspace)
+        # and/or chdir lands elsewhere -> with --append gated OFF they received ZERO boot
+        # instructions -> claude starts (spawn) but never runs SESSION START -> never
+        # boots, in every mesh. Injecting unconditionally GUARANTEES boot regardless of
+        # workspace provisioning / cwd, and is idempotent with a present CLAUDE.md (same
+        # text), so repo-scoped and provisioned launches are unchanged. repo defaults to
+        # the workspace path when there's no repo-lock.
+        cmd += [
+            "--append-system-prompt", MESHCODE_BOOT_PROTOCOL.format(
+                agent=agent, project=resolved_project,
+                role=(agent_role or "MCP-connected agent"),
+                repo=(repo_lock or str(ws))),
+        ]
         cmd.extend(["--", "boot"])
         _launch_cwd = repo_lock or str(ws)
         if not os.path.isdir(_launch_cwd):

{meshcode-2.11.154 → meshcode-2.11.155}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.154 → meshcode-2.11.155}/meshcode.egg-info/SOURCES.txt

@@ -91,6 +91,8 @@ tests/test_preflight_hb_gate.py
 tests/test_pretrust_claude.py
 tests/test_push_guard.py
 tests/test_realtime_event_freshness.py
+tests/test_replica_base_workspace_fallback.py
+tests/test_replica_boot_protocol_unconditional.py
 tests/test_rls_cross_tenant.py
 tests/test_rm_guard.py
 tests/test_rpc_grants.py

{meshcode-2.11.154 → meshcode-2.11.155}/pyproject.toml

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

meshcode-2.11.155/tests/test_replica_base_workspace_fallback.py

@@ -0,0 +1,87 @@
+"""Regression test for task 9698d738 (Samuel P0): "réplicas prenden pero NO bootean".
+
+REAL ROOT CAUSE (Firma A, empirically confirmed): a replica whose workspace was never
+provisioned hits run_agent.py's ".mcp.json missing" path; setup_workspace() fails (e.g.
+the keychain is unreadable non-interactively at hostd spawn) -> run_agent used to
+`return 2` and the process DIED before the MCP server started (instance_id NULL,
+heartbeat NEVER, never ran mc_acquire_agent_lease). Healthy replicas only differed by
+having a PRE-EXISTING workspace (so they skipped setup_workspace).
+
+FIX: _provision_replica_mcp_from_base() clones the BASE agent's known-good .mcp.json
+for the replica (same user -> valid creds), so the replica boots even when fresh setup
+fails. Plus a LOUD-fail (mc_resolve_launch status='failed') so a still-unprovisionable
+replica is visible instead of a silent phantom (covered by the existing
+_report_launch_failure reporter).
+
+These tests exercise the fallback helper in isolation (run_agent's launch fn execs
+claude + chdirs, so it isn't unit-callable end-to-end).
+"""
+import json
+import importlib
+
+import pytest
+
+ra = importlib.import_module("meshcode.run_agent")
+
+
+def _write_base_workspace(root, project, base):
+    ws = root / f"{project}-{base}"
+    ws.mkdir(parents=True, exist_ok=True)
+    doc = {
+        "mcpServers": {
+            f"meshcode-{project}-{base}": {
+                "command": "python",
+                "args": ["-m", "meshcode.meshcode_mcp", "serve"],
+                "env": {
+                    "MESHCODE_AGENT": base,
+                    "MESHCODE_PROJECT": project,
+                    "MESHCODE_PROJECT_ID": "pid-123",
+                    "MESHCODE_KEYCHAIN_PROFILE": "default",
+                    "MESHCODE_API_KEY": "mc_basekey",
+                },
+            }
+        }
+    }
+    (ws / ".mcp.json").write_text(json.dumps(doc), encoding="utf-8")
+    return ws
+
+
+def test_replica_clones_base_mcp(tmp_path, monkeypatch):
+    monkeypatch.setattr(ra, "WORKSPACES_ROOT", tmp_path)
+    _write_base_workspace(tmp_path, "ca-growth", "commander")
+
+    replica_ws = tmp_path / "ca-growth-commander-1"
+    assert ra._provision_replica_mcp_from_base("ca-growth", "commander-1", replica_ws) is True
+
+    doc = json.loads((replica_ws / ".mcp.json").read_text(encoding="utf-8"))
+    servers = doc["mcpServers"]
+    # server id is rewritten to the replica's identity
+    assert "meshcode-ca-growth-commander-1" in servers
+    block = servers["meshcode-ca-growth-commander-1"]
+    # ONLY MESHCODE_AGENT changes — the rest is inherited from the base (valid creds)
+    assert block["env"]["MESHCODE_AGENT"] == "commander-1"
+    assert block["env"]["MESHCODE_API_KEY"] == "mc_basekey"
+    assert block["env"]["MESHCODE_PROJECT"] == "ca-growth"
+    assert block["env"]["MESHCODE_PROJECT_ID"] == "pid-123"
+    # command/args carried verbatim
+    assert block["args"] == ["-m", "meshcode.meshcode_mcp", "serve"]
+
+
+def test_non_replica_name_is_not_cloned(tmp_path, monkeypatch):
+    monkeypatch.setattr(ra, "WORKSPACES_ROOT", tmp_path)
+    _write_base_workspace(tmp_path, "ca-growth", "commander")
+    # 'commander' has no -<N> suffix -> not a replica -> no clone attempted.
+    assert ra._provision_replica_mcp_from_base(
+        "ca-growth", "commander", tmp_path / "ca-growth-commander") is False
+
+
+def test_missing_base_workspace_returns_false(tmp_path, monkeypatch):
+    monkeypatch.setattr(ra, "WORKSPACES_ROOT", tmp_path)
+    # base workspace absent -> nothing to clone -> False (caller then LOUD-fails).
+    assert ra._provision_replica_mcp_from_base(
+        "ca-growth", "commander-2", tmp_path / "ca-growth-commander-2") is False
+
+
+if __name__ == "__main__":
+    import sys
+    sys.exit(pytest.main([__file__, "-q"]))

meshcode-2.11.155/tests/test_replica_boot_protocol_unconditional.py

@@ -0,0 +1,64 @@
+"""Regression sentinel for task 9698d738 (Samuel P0): "réplicas prenden pero NO
+bootean en TODAS las meshes".
+
+ROOT CAUSE: run_agent.py injected the mesh boot protocol via
+`--append-system-prompt MESHCODE_BOOT_PROTOCOL` ONLY inside `if repo_lock:`. But
+hostd-spawned REPLICAS launch with repo_lock=None (no `--repo`) and frequently have
+NO provisioned workspace CLAUDE.md (mc_replicate_agent creates the DB row, not the
+disk workspace). With the --append gated off and no CLAUDE.md to fall back on, the
+replica's Claude Code session received ZERO boot instructions -> it started (the
+terminal "prende") but never ran SESSION START -> never called meshcode_boot ->
+spawn-but-no-boot, in every mesh.
+
+FIX: inject the boot protocol UNCONDITIONALLY (idempotent with a present CLAUDE.md).
+
+This test fails if anyone re-nests the boot protocol under `if repo_lock:`.
+Static AST guard (the launch fn execs claude + chdirs, so it isn't unit-callable).
+"""
+import ast
+import pathlib
+
+RUN_AGENT = pathlib.Path(__file__).parent.parent / "meshcode" / "run_agent.py"
+
+
+def _names_inside_repo_lock_true_branches(tree: ast.AST) -> set[str]:
+    """Every Name id referenced inside the TRUE branch of any `if repo_lock:`."""
+    found: set[str] = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.If) and isinstance(node.test, ast.Name) \
+                and node.test.id == "repo_lock":
+            for stmt in node.body:                # True branch only
+                for sub in ast.walk(stmt):
+                    if isinstance(sub, ast.Name):
+                        found.add(sub.id)
+    return found
+
+
+def test_boot_protocol_injected_unconditionally():
+    tree = ast.parse(RUN_AGENT.read_text(encoding="utf-8"))
+
+    all_names = {n.id for n in ast.walk(tree) if isinstance(n, ast.Name)}
+    assert "MESHCODE_BOOT_PROTOCOL" in all_names, \
+        "MESHCODE_BOOT_PROTOCOL is no longer referenced in run_agent.py — boot protocol lost."
+
+    gated = _names_inside_repo_lock_true_branches(tree)
+    assert "MESHCODE_BOOT_PROTOCOL" not in gated, (
+        "REGRESSION (task 9698d738): the boot protocol (--append-system-prompt "
+        "MESHCODE_BOOT_PROTOCOL) is gated under `if repo_lock:` again. hostd-spawned "
+        "replicas have repo_lock=None and often no ws/CLAUDE.md -> they spawn but never "
+        "boot. Inject MESHCODE_BOOT_PROTOCOL unconditionally (outside the repo_lock if)."
+    )
+
+
+def test_append_system_prompt_flag_present():
+    """The --append-system-prompt flag must still be emitted (it's the carrier)."""
+    consts = {n.value for n in ast.walk(ast.parse(RUN_AGENT.read_text(encoding="utf-8")))
+              if isinstance(n, ast.Constant) and isinstance(n.value, str)}
+    assert "--append-system-prompt" in consts, \
+        "--append-system-prompt flag missing — the boot protocol is no longer delivered."
+
+
+if __name__ == "__main__":
+    test_boot_protocol_injected_unconditionally()
+    test_append_system_prompt_flag_present()
+    print("OK")