meshcode 2.10.32__tar.gz → 2.10.34__tar.gz

{meshcode-2.10.32 → meshcode-2.10.34}/PKG-INFO

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

{meshcode-2.10.32 → meshcode-2.10.34}/meshcode/__init__.py

@@ -1,2 +1,2 @@
 """MeshCode — Real-time communication between AI agents."""
-__version__ = "2.10.32"
+__version__ = "2.10.34"

{meshcode-2.10.32 → meshcode-2.10.34}/meshcode/meshcode_mcp/server.py

@@ -1270,11 +1270,23 @@ async def lifespan(_app):
 # FastMCP server
 # ============================================================
 
-mcp = FastMCP(
-    name=f"meshcode-{PROJECT_NAME}-{AGENT_NAME}",
-    instructions=_INSTRUCTIONS,
-    lifespan=lifespan,
-)
+_DISABLE_LIFESPAN = os.environ.get("MESHCODE_DISABLE_LIFESPAN", "").lower() in ("1", "true", "yes")
+if _DISABLE_LIFESPAN:
+    # Diagnostic mode (2.10.33): bypass lifespan entirely to isolate whether
+    # the Realtime + heartbeat + boot-event machinery is what dies under ESC.
+    # Realtime won't subscribe; meshcode_wait will degrade to DB polling.
+    # meshcode_debug_sleep still works and is our smoke test.
+    mcp = FastMCP(
+        name=f"meshcode-{PROJECT_NAME}-{AGENT_NAME}",
+        instructions=_INSTRUCTIONS,
+    )
+    print("[meshcode-mcp] LIFESPAN DISABLED (MESHCODE_DISABLE_LIFESPAN=1) — diagnostic mode", file=sys.stderr, flush=True)
+else:
+    mcp = FastMCP(
+        name=f"meshcode-{PROJECT_NAME}-{AGENT_NAME}",
+        instructions=_INSTRUCTIONS,
+        lifespan=lifespan,
+    )
 # Belt-and-suspenders: some FastMCP versions don't forward `instructions=` to
 # the underlying lowlevel server's InitializeResult. Set it directly too.
 try:

{meshcode-2.10.32 → meshcode-2.10.34}/meshcode/run_agent.py

@@ -177,7 +177,7 @@ def _check_agent_ownership(agent: str, project: str) -> Optional[str]:
         import importlib
         secrets_mod = importlib.import_module("meshcode.secrets")
     except Exception:
-        return None  # Can't check — let the RPC catch it later
+        return "cannot load auth modules; re-install meshcode"
 
     # Try scoped profile first (from invite join), then default
     scoped_profile = f"mesh:{project}:{agent}"
@@ -186,7 +186,7 @@ def _check_agent_ownership(agent: str, project: str) -> Optional[str]:
         profile = os.environ.get("MESHCODE_KEYCHAIN_PROFILE") or "default"
         api_key = secrets_mod.get_api_key(profile=profile)
     if not api_key:
-        return None  # No key — RPC will reject later
+        return "not logged in — run `meshcode login <api_key>` first"
 
     sb = _load_supabase_env()
     try:
@@ -208,35 +208,35 @@ def _check_agent_ownership(agent: str, project: str) -> Optional[str]:
         )
         with urlopen(req, timeout=10) as resp:
             data = json.loads(resp.read().decode())
-    except Exception:
-        return None  # Network error — let the RPC catch it later
+    except Exception as e:
+        return f"could not verify meshwork access ({e}); refusing to launch"
 
     if isinstance(data, dict) and data.get("error"):
         return data["error"]
+    if not isinstance(data, dict) or not data.get("ok"):
+        return "ownership check returned unexpected response; refusing to launch"
     return None
 
 
-def _try_auto_setup(agent: str, project: Optional[str] = None) -> Optional[Tuple[Path, str]]:
-    """If agent exists on the server but has no local workspace, auto-create it.
+def _resolve_user_projects_for_agent(agent: str) -> Optional[list]:
+    """Ask the server which meshworks owned by the current user have this agent.
 
-    Returns (workspace_path, project_name) on success, None on failure.
+    Returns list of dicts [{project_name, project_id, role}], or None on auth/network error.
+    Always scoped to the authenticated user (RPC enforces owner_id = caller user).
     """
     try:
-        from .setup_clients import _load_supabase_env, setup_workspace
+        from .setup_clients import _load_supabase_env
         import importlib
         secrets_mod = importlib.import_module("meshcode.secrets")
     except Exception:
         return None
 
-    import os as _os
-    profile = _os.environ.get("MESHCODE_KEYCHAIN_PROFILE") or "default"
+    profile = os.environ.get("MESHCODE_KEYCHAIN_PROFILE") or "default"
     api_key = secrets_mod.get_api_key(profile=profile)
     if not api_key:
         return None
 
     sb = _load_supabase_env()
-
-    # Ask the server which project(s) this agent belongs to
     try:
         from urllib.request import Request, urlopen
         body = json.dumps({"p_api_key": api_key, "p_agent_name": agent}).encode()
@@ -256,27 +256,36 @@ def _try_auto_setup(agent: str, project: Optional[str] = None) -> Optional[Tuple
         return None
 
     if not isinstance(data, dict) or data.get("error"):
+        return []
+    projects = data.get("projects") or []
+    return projects if isinstance(projects, list) else []
+
+
+def _try_auto_setup(agent: str, project: str) -> Optional[Tuple[Path, str]]:
+    """If agent exists on the server but has no local workspace, auto-create it.
+
+    Caller MUST pass an explicit project — this function never auto-picks one.
+    Returns (workspace_path, project_name) on success, None on failure.
+    """
+    if not project:
         return None
 
-    projects = data.get("projects", [])
+    try:
+        from .setup_clients import setup_workspace
+    except Exception:
+        return None
+
+    projects = _resolve_user_projects_for_agent(agent)
     if not projects:
         return None
 
-    # If user specified a project, filter to that one
-    if project:
-        projects = [p for p in projects if p["project_name"] == project]
-        if not projects:
-            return None
-
-    if len(projects) > 1:
-        print(f"[meshcode] Agent '{agent}' exists in multiple projects:", file=sys.stderr)
-        for p in projects:
-            print(f"[meshcode]   meshcode run {agent} --project {p['project_name']}", file=sys.stderr)
-        print(f"[meshcode] Specify which one with --project.", file=sys.stderr)
+    # Filter to the explicitly requested project. Never silently auto-pick.
+    match = [p for p in projects if p.get("project_name") == project]
+    if not match:
         return None
 
-    resolved_project = projects[0]["project_name"]
-    role = projects[0].get("role", "")
+    resolved_project = match[0]["project_name"]
+    role = match[0].get("role", "")
 
     print(f"[meshcode] Workspace recreated automatically for agent '{agent}' (project: {resolved_project})")
     rc = setup_workspace(resolved_project, agent, role)
@@ -298,50 +307,50 @@ def _load_registry() -> dict:
         return {}
 
 
-def _find_agent_workspace(agent: str, project: Optional[str] = None, quiet: bool = False) -> Optional[Tuple[Path, str]]:
-    """Look up the agent in the registry. Returns (workspace_path, project_name) or None.
+def _find_agent_workspace(agent: str, project: str, quiet: bool = False) -> Optional[Tuple[Path, str]]:
+    """Look up the agent's workspace for an EXPLICIT project. Returns (path, project) or None.
 
-    If multiple agents share the same name across projects, requires the
-    user to disambiguate by passing project explicitly.
+    Caller MUST pass project — this function never auto-picks across meshworks.
     When quiet=True, suppresses error messages (used before auto-setup fallback).
     """
+    if not project:
+        return None
+
     reg = _load_registry()
     agents = reg.get("agents", {})
 
-    # Direct hit by agent name (current model: agent names unique within registry)
     info = agents.get(agent)
-    if info:
+    if info and info.get("project") == project:
         ws = Path(info["workspace"])
-        if not ws.exists():
-            # Don't print error in quiet mode — caller will try auto-setup
-            return None
-        if project and info.get("project") != project:
-            if not quiet:
-                print(f"[meshcode] ERROR: agent '{agent}' belongs to project '{info.get('project')}', not '{project}'", file=sys.stderr)
-            return None
-        return ws, info.get("project", "")
-
-    # Fallback: scan ~/meshcode for any dir matching <project>-<agent>
-    if project:
-        ws = WORKSPACES_ROOT / f"{project}-{agent}"
         if ws.exists():
             return ws, project
-    else:
-        # Scan all workspaces for any matching <*>-<agent>
-        if WORKSPACES_ROOT.exists():
-            matches = [p for p in WORKSPACES_ROOT.iterdir() if p.is_dir() and p.name.endswith(f"-{agent}")]
-            if len(matches) == 1:
-                return matches[0], matches[0].name.rsplit(f"-{agent}", 1)[0]
-            if len(matches) > 1:
-                print(f"[meshcode] ERROR: agent '{agent}' exists in multiple projects:", file=sys.stderr)
-                for m in matches:
-                    print(f"[meshcode]   {m.name}", file=sys.stderr)
-                print(f"[meshcode] Disambiguate: meshcode run {agent} --project <name>", file=sys.stderr)
-                return None
+        # Registry points at a missing dir — caller will try auto-setup
+        return None
+
+    if info and info.get("project") != project and not quiet:
+        print(f"[meshcode] NOTE: registry has agent '{agent}' under project '{info.get('project')}', not '{project}'", file=sys.stderr)
+
+    # Filesystem fallback: ~/meshcode/<project>-<agent>
+    ws = WORKSPACES_ROOT / f"{project}-{agent}"
+    if ws.exists():
+        return ws, project
 
     return None
 
 
+def _list_local_projects_for_agent(agent: str) -> list:
+    """Return project names whose local workspace dir matches <project>-<agent>."""
+    if not WORKSPACES_ROOT.exists():
+        return []
+    out = []
+    for p in WORKSPACES_ROOT.iterdir():
+        if p.is_dir() and p.name.endswith(f"-{agent}"):
+            proj = p.name.rsplit(f"-{agent}", 1)[0]
+            if proj:
+                out.append(proj)
+    return out
+
+
 def _detect_editor() -> Optional[str]:
     """Pick the user's preferred MCP-aware editor."""
     override = os.environ.get("MESHCODE_EDITOR", "").strip().lower()
@@ -406,13 +415,35 @@ def run(agent: str, project: Optional[str] = None, editor_override: Optional[str
         print(f"[meshcode]        (or copy this exact line into a new terminal: meshcode run {agent})", file=sys.stderr)
         return 2
 
+    # ── Require explicit meshwork ────────────────────────────────────
+    # Agent names are not globally unique (e.g. "commander" exists in many
+    # meshworks). Without an explicit meshwork, we cannot safely pick one
+    # — even if only one is visible locally, another could exist on the
+    # server. Force the user to disambiguate and authenticate against a
+    # specific meshwork they own.
+    if not project:
+        print(f"[meshcode] ERROR: specify which meshwork '{agent}' belongs to.", file=sys.stderr)
+        local_projects = _list_local_projects_for_agent(agent)
+        server_projects = _resolve_user_projects_for_agent(agent) or []
+        candidates = set(local_projects) | {p.get("project_name") for p in server_projects if p.get("project_name")}
+        if candidates:
+            print(f"[meshcode] '{agent}' is available in these meshworks of yours:", file=sys.stderr)
+            for name in sorted(candidates):
+                print(f"[meshcode]   meshcode run {name}/{agent}", file=sys.stderr)
+        else:
+            print(f"[meshcode] No meshworks of yours contain agent '{agent}'.", file=sys.stderr)
+            print(f"[meshcode] Create one first:  meshcode setup <meshwork> {agent}", file=sys.stderr)
+        print(f"[meshcode] Usage: meshcode run <meshwork>/{agent}   (or --project <meshwork>)", file=sys.stderr)
+        return 2
+
     found = _find_agent_workspace(agent, project, quiet=True)
     if not found:
-        # Auto-setup: if agent exists on the server, recreate workspace
+        # Auto-setup: if agent exists on the server under THIS meshwork, recreate workspace
         found = _try_auto_setup(agent, project)
         if not found:
-            print(f"[meshcode] ERROR: no workspace found for agent '{agent}'", file=sys.stderr)
-            print(f"[meshcode]        Run `meshcode setup <project> {agent}` first.", file=sys.stderr)
+            print(f"[meshcode] ERROR: agent '{agent}' not found in meshwork '{project}' for your account.", file=sys.stderr)
+            print(f"[meshcode]        Run `meshcode setup {project} {agent}` first,", file=sys.stderr)
+            print(f"[meshcode]        or check the meshwork name at https://meshcode.io", file=sys.stderr)
             return 2
     ws, resolved_project = found
 

{meshcode-2.10.32 → meshcode-2.10.34}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.10.32 → meshcode-2.10.34}/pyproject.toml

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