meshcode 1.2.6__tar.gz → 1.3.0__tar.gz

{meshcode-1.2.6 → meshcode-1.3.0}/PKG-INFO

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

{meshcode-1.2.6 → meshcode-1.3.0}/meshcode/__init__.py

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

{meshcode-1.2.6 → meshcode-1.3.0}/meshcode/comms_v4.py

@@ -1888,17 +1888,25 @@ if __name__ == "__main__":
         disconnect_terminal(proj, name)
 
     elif cmd == "setup":
-        if len(sys.argv) < 5:
-            print("Usage: meshcode setup <client> <project> <agent> [role]")
-            print("Clients: claude-code, cursor, cline, claude-desktop")
+        # Two forms supported:
+        #   meshcode setup <project> <agent> [role]            → workspace flow (1.3+)
+        #   meshcode setup <client> <project> <agent> [role]   → legacy global flow
+        # Dispatched by setup_clients.setup() which detects which form was used.
+        import importlib
+        _setup_dispatcher = importlib.import_module("meshcode.setup_clients").setup
+        sys.exit(_setup_dispatcher(*sys.argv[2:]))
+
+    elif cmd == "run":
+        # meshcode run <agent> [--project <name>] [--editor claude|cursor|code]
+        if len(sys.argv) < 3:
+            print("Usage: meshcode run <agent> [--project <name>] [--editor claude|cursor|code]")
             sys.exit(1)
-        client = sys.argv[2]
-        project = sys.argv[3]
-        agent = sys.argv[4]
-        role = sys.argv[5] if len(sys.argv) > 5 else ""
+        agent = sys.argv[2]
+        proj_override = flags.get("project")
+        editor_override = flags.get("editor")
         import importlib
-        _setup_client = importlib.import_module("meshcode.setup_clients").setup
-        sys.exit(_setup_client(client, project, agent, role))
+        _run = importlib.import_module("meshcode.run_agent").run
+        sys.exit(_run(agent, project=proj_override, editor_override=editor_override))
 
     elif cmd == "login":
         key = sys.argv[2] if len(sys.argv) > 2 else ""

{meshcode-1.2.6 → meshcode-1.3.0}/meshcode/meshcode_mcp/server.py

@@ -78,12 +78,37 @@ if isinstance(_register_result, dict) and _register_result.get("error"):
     print(f"[meshcode-mcp] WARNING: register failed: {_register_result['error']}", file=sys.stderr)
 
 # Flip to online so the dashboard reflects the live MCP session.
-# Without this the agent stays in 'needs_setup' / 'offline' even though
-# heartbeat is running. The set_status helper updates status + last_heartbeat.
-try:
-    be.set_status(_PROJECT_ID, AGENT_NAME, "online", "MCP session active")
-except Exception as _e:
-    print(f"[meshcode-mcp] WARNING: could not flip status to online: {_e}", file=sys.stderr)
+# Use the SECURITY DEFINER RPC (mc_agent_set_status_by_api_key) so we
+# bypass RLS — the publishable key has no JWT context and cannot UPDATE
+# mc_agents directly. The RPC validates ownership via api_key.
+def _flip_status(status: str, task: str = "") -> bool:
+    api_key = os.environ.get("MESHCODE_API_KEY", "")
+    if not api_key:
+        # Last-resort fallback: try the direct PATCH (may be denied by RLS)
+        try:
+            be.set_status(_PROJECT_ID, AGENT_NAME, status, task)
+            return True
+        except Exception:
+            return False
+    try:
+        r = be.sb_rpc("mc_agent_set_status_by_api_key", {
+            "p_api_key": api_key,
+            "p_project_id": _PROJECT_ID,
+            "p_agent_name": AGENT_NAME,
+            "p_status": status,
+            "p_task": task,
+        })
+        if isinstance(r, dict) and r.get("ok"):
+            return True
+        if isinstance(r, dict) and r.get("error"):
+            log.warning(f"set_status RPC: {r['error']}")
+        return False
+    except Exception as e:
+        log.warning(f"set_status RPC threw: {e}")
+        return False
+
+if not _flip_status("online", "MCP session active"):
+    print(f"[meshcode-mcp] WARNING: could not flip status to online", file=sys.stderr)
 
 
 # ============================================================

meshcode-1.3.0/meshcode/run_agent.py

@@ -0,0 +1,151 @@
+"""`meshcode run <agent>` — universal agent launcher.
+
+Looks up the agent's workspace dir (created by `meshcode setup`) in the
+registry at ~/meshcode/.registry.json, auto-detects the user's MCP-aware
+editor, and launches it pointing at that workspace's isolated .mcp.json
+so ONLY this one agent loads in the new window.
+
+Editor detection order (first match wins):
+    1. $MESHCODE_EDITOR env var (explicit override: claude / cursor / code)
+    2. claude (Claude Code) — uses --mcp-config flag for per-instance config
+    3. cursor — opens Cursor in the workspace dir (reads .cursor/mcp.json)
+    4. code (VS Code, used by Cline) — opens VS Code in the workspace dir
+       (Cline reads .vscode/mcp.json)
+
+The workspace dir contains all three config files (.mcp.json,
+.cursor/mcp.json, .vscode/mcp.json) so any of these editors works
+identically. Closing the editor window kills the MCP subprocess and
+the agent flips to offline.
+"""
+import json
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import Optional, Tuple
+
+WORKSPACES_ROOT = Path.home() / "meshcode"
+REGISTRY_PATH = WORKSPACES_ROOT / ".registry.json"
+
+
+def _load_registry() -> dict:
+    if not REGISTRY_PATH.exists():
+        return {}
+    try:
+        return json.loads(REGISTRY_PATH.read_text())
+    except Exception:
+        return {}
+
+
+def _find_agent_workspace(agent: str, project: Optional[str] = None) -> Optional[Tuple[Path, str]]:
+    """Look up the agent in the registry. Returns (workspace_path, project_name) or None.
+
+    If multiple agents share the same name across projects, requires the
+    user to disambiguate by passing project explicitly.
+    """
+    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:
+        ws = Path(info["workspace"])
+        if not ws.exists():
+            print(f"[meshcode] ERROR: workspace dir for '{agent}' is missing: {ws}", file=sys.stderr)
+            print(f"[meshcode]        Re-run: meshcode setup {info.get('project','<project>')} {agent}", file=sys.stderr)
+            return None
+        if project and info.get("project") != project:
+            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
+
+    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)
+    return None
+
+
+def _detect_editor() -> Optional[str]:
+    """Pick the user's preferred MCP-aware editor."""
+    override = os.environ.get("MESHCODE_EDITOR", "").strip().lower()
+    if override:
+        if shutil.which(override):
+            return override
+        print(f"[meshcode] WARNING: MESHCODE_EDITOR='{override}' not found in PATH", file=sys.stderr)
+
+    for cmd in ("claude", "cursor", "code"):
+        if shutil.which(cmd):
+            return cmd
+    return None
+
+
+def run(agent: str, project: Optional[str] = None, editor_override: Optional[str] = None) -> int:
+    """Launch the user's editor with ONLY the named agent's MCP server loaded."""
+    found = _find_agent_workspace(agent, project)
+    if not found:
+        return 2
+    ws, resolved_project = found
+    server_id = f"meshcode-{resolved_project}-{agent}"
+
+    editor = editor_override or _detect_editor()
+    if not editor:
+        print("[meshcode] ERROR: no MCP-aware editor found in PATH (claude / cursor / code).", file=sys.stderr)
+        print(f"[meshcode]        Workspace is ready at: {ws}", file=sys.stderr)
+        print("[meshcode]        Open it manually with the editor of your choice.", file=sys.stderr)
+        return 2
+
+    print(f"[meshcode] Launching {editor} for agent '{agent}' (project: {resolved_project})")
+    print(f"[meshcode]   Workspace: {ws}")
+    print(f"[meshcode]   MCP server: {server_id}")
+    print(f"[meshcode]   Closing the editor will flip this agent offline.")
+    print()
+
+    if editor == "claude":
+        # Claude Code: pass --mcp-config to point at the workspace's .mcp.json
+        # and --strict-mcp-config so it ignores ~/.claude.json's mcpServers.
+        cmd = [
+            editor,
+            "--mcp-config", str(ws / ".mcp.json"),
+            "--strict-mcp-config",
+            "--dangerously-skip-permissions",
+        ]
+        try:
+            os.chdir(ws)
+        except Exception:
+            pass
+    elif editor == "cursor":
+        # Cursor reads .cursor/mcp.json from the workspace cwd.
+        cmd = [editor, str(ws)]
+    elif editor == "code":
+        # VS Code (Cline reads .vscode/mcp.json from workspace cwd).
+        cmd = [editor, str(ws)]
+    else:
+        cmd = [editor, str(ws)]
+
+    try:
+        # Replace this process with the editor so the user gets a clean tab.
+        os.execvp(cmd[0], cmd)
+    except FileNotFoundError:
+        print(f"[meshcode] ERROR: '{editor}' not found in PATH", file=sys.stderr)
+        return 127
+    except Exception as e:
+        print(f"[meshcode] ERROR launching {editor}: {e}", file=sys.stderr)
+        return 1

meshcode-1.3.0/meshcode/setup_clients.py

@@ -0,0 +1,297 @@
+"""Per-agent workspace creator for `meshcode setup`.
+
+NEW MODEL (1.3.0): instead of polluting the user's global MCP config
+(~/.claude.json, ~/.cursor/mcp.json, ...), each `meshcode setup <project>
+<agent>` creates an isolated workspace directory at:
+
+    ~/meshcode/<project>-<agent>/
+
+containing a single .mcp.json with ONLY that agent's MCP server entry.
+The user then runs `meshcode run <agent>` to launch their editor with
+that workspace, and ONLY that one agent goes online. Closing the editor
+window flips the agent offline. No cross-window status pollution.
+
+Backward compatibility: the old `meshcode setup <client> <project>
+<agent>` form still works for the global-config flow (kept for users
+on Claude Desktop, which doesn't support per-instance MCP configs).
+"""
+import json
+import os
+import platform
+import sys
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+
+def _load_credentials() -> Dict[str, str]:
+    creds_path = Path.home() / ".meshcode" / "credentials.json"
+    if not creds_path.exists():
+        print("[meshcode] ERROR: No credentials found. Run `meshcode login <api_key>` first.", file=sys.stderr)
+        sys.exit(2)
+    return json.loads(creds_path.read_text())
+
+
+def _load_supabase_env() -> Dict[str, str]:
+    """Read SUPABASE_URL/SUPABASE_KEY from env or ~/.meshcode/env, fall back to publishable defaults."""
+    url = os.environ.get("SUPABASE_URL", "")
+    key = os.environ.get("SUPABASE_KEY", "")
+    if not url or not key:
+        env_file = Path.home() / ".meshcode" / "env"
+        if env_file.exists():
+            for line in env_file.read_text().splitlines():
+                line = line.strip()
+                if line.startswith("export "):
+                    line = line[7:]
+                if "=" in line:
+                    k, v = line.split("=", 1)
+                    v = v.strip().strip('"').strip("'")
+                    if k == "SUPABASE_URL" and not url:
+                        url = v
+                    elif k == "SUPABASE_KEY" and not key:
+                        key = v
+    if not url:
+        url = "https://wwgzzmydrwrjgaebspdo.supabase.co"
+    if not key:
+        key = "sb_publishable_0qf0U1GURopPIxLR8Vu7eQ_5grflPP4"
+    return {"SUPABASE_URL": url, "SUPABASE_KEY": key}
+
+
+def _resolve_project_id(api_key: str, project: str, sb: Dict[str, str]) -> str:
+    """Call mc_resolve_project SECURITY DEFINER RPC to get the project_id."""
+    try:
+        from urllib.request import Request as _Req, urlopen as _urlopen
+        body = json.dumps({"p_api_key": api_key, "p_project_name": project}).encode()
+        req = _Req(
+            f"{sb['SUPABASE_URL']}/rest/v1/rpc/mc_resolve_project",
+            data=body,
+            method="POST",
+            headers={
+                "apikey": sb["SUPABASE_KEY"],
+                "Authorization": f"Bearer {sb['SUPABASE_KEY']}",
+                "Content-Type": "application/json",
+            },
+        )
+        with _urlopen(req, timeout=10) as resp:
+            data = json.loads(resp.read().decode())
+            if isinstance(data, dict) and data.get("project_id"):
+                return data["project_id"]
+            if isinstance(data, dict) and data.get("error"):
+                print(f"[meshcode] ERROR: could not resolve project '{project}': {data['error']}", file=sys.stderr)
+                sys.exit(2)
+    except Exception as e:
+        print(f"[meshcode] WARNING: project_id resolution failed ({e}); MCP server will retry at boot", file=sys.stderr)
+    return ""
+
+
+def _build_server_block(project: str, project_id: str, agent: str, role: str,
+                         api_key: str, sb: Dict[str, str]) -> Dict[str, Any]:
+    return {
+        "command": sys.executable or "python3",
+        "args": ["-m", "meshcode.meshcode_mcp", "serve"],
+        "env": {
+            "MESHCODE_PROJECT": project,
+            "MESHCODE_PROJECT_ID": project_id,
+            "MESHCODE_AGENT": agent,
+            "MESHCODE_ROLE": role or "MCP-connected agent",
+            "MESHCODE_API_KEY": api_key,
+            "SUPABASE_URL": sb["SUPABASE_URL"],
+            "SUPABASE_KEY": sb["SUPABASE_KEY"],
+        },
+    }
+
+
+def _atomic_write_json(path: Path, data: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    tmp.write_text(json.dumps(data, indent=2))
+    tmp.replace(path)
+
+
+# ============================================================
+# WORKSPACE MODEL (1.3.0+) — one isolated dir per agent
+# ============================================================
+
+WORKSPACES_ROOT = Path.home() / "meshcode"
+
+
+def _workspace_dir(project: str, agent: str) -> Path:
+    return WORKSPACES_ROOT / f"{project}-{agent}"
+
+
+def setup_workspace(project: str, agent: str, role: str = "") -> int:
+    """Create an isolated workspace dir at ~/meshcode/<project>-<agent>/ with
+    .mcp.json containing ONLY this agent's server entry. Universal for any
+    MCP-compatible editor that supports per-directory configs (Claude Code via
+    --mcp-config flag, Cursor + Cline via .cursor/mcp.json + .vscode/mcp.json).
+    """
+    creds = _load_credentials()
+    sb = _load_supabase_env()
+    api_key = creds.get("api_key", "")
+    project_id = _resolve_project_id(api_key, project, sb)
+
+    server_id = f"meshcode-{project}-{agent}"
+    server_block = _build_server_block(project, project_id, agent, role, api_key, sb)
+
+    ws = _workspace_dir(project, agent)
+    ws.mkdir(parents=True, exist_ok=True)
+
+    # Write 3 config files inside the workspace so any MCP-aware editor
+    # opened in this dir picks up the meshcode server.
+    #
+    #   .mcp.json              — Claude Code project-scoped MCP config
+    #   .cursor/mcp.json       — Cursor workspace-scoped MCP config
+    #   .vscode/mcp.json       — Cline / VS Code workspace-scoped MCP config
+    #
+    # All three contain the SAME single server entry. Whichever editor the
+    # user opens here will see exactly one agent: this one.
+    server_doc = {"mcpServers": {server_id: server_block}}
+    _atomic_write_json(ws / ".mcp.json", server_doc)
+    _atomic_write_json(ws / ".cursor" / "mcp.json", server_doc)
+    _atomic_write_json(ws / ".vscode" / "mcp.json", server_doc)
+
+    # A tiny manifest the `meshcode run` command reads to know where this
+    # workspace lives. Stored at the root so `meshcode run <agent>` can find
+    # it without scanning every dir.
+    registry_path = WORKSPACES_ROOT / ".registry.json"
+    registry: Dict[str, Any] = {}
+    if registry_path.exists():
+        try:
+            registry = json.loads(registry_path.read_text())
+        except Exception:
+            registry = {}
+    registry.setdefault("agents", {})[agent] = {
+        "project": project,
+        "workspace": str(ws),
+        "server_id": server_id,
+        "role": role,
+    }
+    _atomic_write_json(registry_path, registry)
+
+    print(f"[meshcode] ✓ Workspace created for agent '{agent}' (project: {project})")
+    print(f"[meshcode]   Path: {ws}")
+    print(f"[meshcode]")
+    print(f"[meshcode]   To launch this agent in your editor:")
+    print(f"[meshcode]     meshcode run {agent}")
+    print(f"[meshcode]")
+    print(f"[meshcode]   Closing the editor window flips this agent offline.")
+    print(f"[meshcode]   Other agents stay independent — no cross-window pollution.")
+    return 0
+
+
+# ============================================================
+# LEGACY GLOBAL-CONFIG MODEL (kept for Claude Desktop)
+# ============================================================
+
+CLIENT_CONFIG_PATHS = {
+    "claude-code": {
+        "Darwin":  Path.home() / ".claude.json",
+        "Linux":   Path.home() / ".claude.json",
+        "Windows": Path.home() / ".claude.json",
+    },
+    "cursor": {
+        "Darwin":  Path.home() / ".cursor" / "mcp.json",
+        "Linux":   Path.home() / ".cursor" / "mcp.json",
+        "Windows": Path.home() / ".cursor" / "mcp.json",
+    },
+    "cline": {
+        "Darwin":  Path.home() / "Library" / "Application Support" / "Code" / "User" / "globalStorage" / "saoudrizwan.claude-dev" / "settings" / "cline_mcp_settings.json",
+        "Linux":   Path.home() / ".config" / "Code" / "User" / "globalStorage" / "saoudrizwan.claude-dev" / "settings" / "cline_mcp_settings.json",
+        "Windows": Path.home() / "AppData" / "Roaming" / "Code" / "User" / "globalStorage" / "saoudrizwan.claude-dev" / "settings" / "cline_mcp_settings.json",
+    },
+    "claude-desktop": {
+        "Darwin":  Path.home() / "Library" / "Application Support" / "Claude" / "claude_desktop_config.json",
+        "Linux":   Path.home() / ".config" / "Claude" / "claude_desktop_config.json",
+        "Windows": Path.home() / "AppData" / "Roaming" / "Claude" / "claude_desktop_config.json",
+    },
+}
+
+CLIENT_DISPLAY_NAMES = {
+    "claude-code":    "Claude Code",
+    "cursor":         "Cursor",
+    "cline":          "Cline (VS Code)",
+    "claude-desktop": "Claude Desktop",
+}
+
+
+def setup_global(client: str, project: str, agent: str, role: str = "") -> int:
+    """LEGACY: write to the user's GLOBAL MCP config file. All agents that
+    setup this way will load in EVERY window of the editor — they all show
+    online whenever any window is open. Kept for Claude Desktop and other
+    clients that don't support per-instance configs."""
+    if client not in CLIENT_CONFIG_PATHS:
+        print(f"[meshcode] ERROR: Unknown client '{client}'. Supported: {', '.join(CLIENT_CONFIG_PATHS)}", file=sys.stderr)
+        return 2
+
+    creds = _load_credentials()
+    sb = _load_supabase_env()
+    api_key = creds.get("api_key", "")
+    project_id = _resolve_project_id(api_key, project, sb)
+
+    os_name = platform.system()
+    config_path = CLIENT_CONFIG_PATHS[client].get(os_name)
+    if config_path is None:
+        print(f"[meshcode] ERROR: '{client}' is not supported on {os_name}", file=sys.stderr)
+        return 2
+
+    existing: Dict[str, Any] = {}
+    if config_path.exists():
+        try:
+            existing = json.loads(config_path.read_text())
+        except json.JSONDecodeError:
+            print(f"[meshcode] WARNING: {config_path} exists but is not valid JSON.", file=sys.stderr)
+            return 2
+
+    if not isinstance(existing, dict):
+        existing = {}
+
+    servers = existing.setdefault("mcpServers", {})
+    if not isinstance(servers, dict):
+        print(f"[meshcode] ERROR: 'mcpServers' in {config_path} is not an object", file=sys.stderr)
+        return 2
+
+    server_id = f"meshcode-{project}-{agent}"
+    servers[server_id] = _build_server_block(project, project_id, agent, role, api_key, sb)
+    _atomic_write_json(config_path, existing)
+
+    display = CLIENT_DISPLAY_NAMES[client]
+    print(f"[meshcode] MCP server '{server_id}' added to {display} GLOBAL config")
+    print(f"[meshcode]   Path: {config_path}")
+    print(f"[meshcode]   ⚠️  Global mode: this agent will appear in EVERY window of {display}.")
+    print(f"[meshcode]   For per-window agent isolation, use the workspace flow instead:")
+    print(f"[meshcode]     meshcode setup {project} {agent}")
+    print(f"[meshcode]     meshcode run {agent}")
+    return 0
+
+
+# ============================================================
+# DISPATCHER (called from comms_v4.py CLI)
+# ============================================================
+
+def setup(*args) -> int:
+    """Smart dispatcher.
+
+    Forms supported:
+        meshcode setup <project> <agent> [role]            → workspace flow (NEW)
+        meshcode setup <client> <project> <agent> [role]   → legacy global flow
+
+    Detection: if the first arg is one of the known client slugs, fall back
+    to the legacy global flow. Otherwise treat the first arg as a project
+    name and create a workspace.
+    """
+    if not args:
+        print("Usage:", file=sys.stderr)
+        print("  meshcode setup <project> <agent> [role]           # workspace flow (recommended)", file=sys.stderr)
+        print("  meshcode setup <client> <project> <agent> [role]  # legacy global flow", file=sys.stderr)
+        print("  Clients: claude-code, cursor, cline, claude-desktop", file=sys.stderr)
+        return 1
+
+    if args[0] in CLIENT_CONFIG_PATHS:
+        if len(args) < 3:
+            print("Usage: meshcode setup <client> <project> <agent> [role]", file=sys.stderr)
+            return 1
+        return setup_global(args[0], args[1], args[2], args[3] if len(args) > 3 else "")
+
+    if len(args) < 2:
+        print("Usage: meshcode setup <project> <agent> [role]", file=sys.stderr)
+        return 1
+    return setup_workspace(args[0], args[1], args[2] if len(args) > 2 else "")

{meshcode-1.2.6 → meshcode-1.3.0}/meshcode.egg-info/PKG-INFO

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

{meshcode-1.2.6 → meshcode-1.3.0}/meshcode.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ meshcode/comms_v4.py
 meshcode/launcher.py
 meshcode/launcher_install.py
 meshcode/protocol_v2.py
+meshcode/run_agent.py
 meshcode/setup_clients.py
 meshcode.egg-info/PKG-INFO
 meshcode.egg-info/SOURCES.txt

{meshcode-1.2.6 → meshcode-1.3.0}/pyproject.toml

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

meshcode-1.2.6/meshcode/setup_clients.py

@@ -1,173 +0,0 @@
-"""Per-client MCP server config writers for `meshcode setup <client>`.
-
-Supported clients: claude-code, cursor, cline, claude-desktop.
-
-Each writer:
-1. Resolves the right config file path for the current OS.
-2. Loads existing JSON (or empty dict) and merges the meshcode MCP server entry
-   under "mcpServers". Never clobbers other entries.
-3. Writes back atomically (temp file + rename).
-4. Prints a success message with the path and "restart {client}" instructions.
-"""
-import json
-import os
-import platform
-import sys
-from pathlib import Path
-from typing import Dict, Any
-
-
-def _load_credentials() -> Dict[str, str]:
-    creds_path = Path.home() / ".meshcode" / "credentials.json"
-    if not creds_path.exists():
-        print("[meshcode] ERROR: No credentials found. Run `meshcode login <api_key>` first.", file=sys.stderr)
-        sys.exit(2)
-    return json.loads(creds_path.read_text())
-
-
-def _load_supabase_env() -> Dict[str, str]:
-    """Read SUPABASE_URL/SUPABASE_KEY from env or ~/.meshcode/env."""
-    url = os.environ.get("SUPABASE_URL", "")
-    key = os.environ.get("SUPABASE_KEY", "")
-    if not url or not key:
-        env_file = Path.home() / ".meshcode" / "env"
-        if env_file.exists():
-            for line in env_file.read_text().splitlines():
-                line = line.strip()
-                if line.startswith("export "):
-                    line = line[7:]
-                if "=" in line:
-                    k, v = line.split("=", 1)
-                    v = v.strip().strip('"').strip("'")
-                    if k == "SUPABASE_URL" and not url:
-                        url = v
-                    elif k == "SUPABASE_KEY" and not key:
-                        key = v
-    if not url:
-        url = "https://wwgzzmydrwrjgaebspdo.supabase.co"
-    if not key:
-        key = "sb_publishable_0qf0U1GURopPIxLR8Vu7eQ_5grflPP4"
-    return {"SUPABASE_URL": url, "SUPABASE_KEY": key}
-
-
-CLIENT_CONFIG_PATHS = {
-    "claude-code": {
-        "Darwin":  Path.home() / ".claude.json",
-        "Linux":   Path.home() / ".claude.json",
-        "Windows": Path.home() / ".claude.json",
-    },
-    "cursor": {
-        "Darwin":  Path.home() / ".cursor" / "mcp.json",
-        "Linux":   Path.home() / ".cursor" / "mcp.json",
-        "Windows": Path.home() / ".cursor" / "mcp.json",
-    },
-    "cline": {
-        "Darwin":  Path.home() / "Library" / "Application Support" / "Code" / "User" / "globalStorage" / "saoudrizwan.claude-dev" / "settings" / "cline_mcp_settings.json",
-        "Linux":   Path.home() / ".config" / "Code" / "User" / "globalStorage" / "saoudrizwan.claude-dev" / "settings" / "cline_mcp_settings.json",
-        "Windows": Path.home() / "AppData" / "Roaming" / "Code" / "User" / "globalStorage" / "saoudrizwan.claude-dev" / "settings" / "cline_mcp_settings.json",
-    },
-    "claude-desktop": {
-        "Darwin":  Path.home() / "Library" / "Application Support" / "Claude" / "claude_desktop_config.json",
-        "Linux":   Path.home() / ".config" / "Claude" / "claude_desktop_config.json",
-        "Windows": Path.home() / "AppData" / "Roaming" / "Claude" / "claude_desktop_config.json",
-    },
-}
-
-CLIENT_DISPLAY_NAMES = {
-    "claude-code":    "Claude Code",
-    "cursor":         "Cursor",
-    "cline":          "Cline (VS Code)",
-    "claude-desktop": "Claude Desktop",
-}
-
-
-def _atomic_write_json(path: Path, data: dict) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    tmp = path.with_suffix(path.suffix + ".tmp")
-    tmp.write_text(json.dumps(data, indent=2))
-    tmp.replace(path)
-
-
-def setup(client: str, project: str, agent: str, role: str = "") -> int:
-    """Write MCP server config block for the given client. Returns 0 on success."""
-    if client not in CLIENT_CONFIG_PATHS:
-        print(f"[meshcode] ERROR: Unknown client '{client}'. Supported: {', '.join(CLIENT_CONFIG_PATHS)}", file=sys.stderr)
-        return 2
-
-    creds = _load_credentials()
-    sb = _load_supabase_env()
-    api_key = creds.get("api_key", "")
-
-    # Resolve project_id via the SECURITY DEFINER RPC so we don't depend on
-    # RLS letting the publishable key SELECT mc_projects at MCP server boot.
-    project_id = ""
-    try:
-        import json as _json
-        from urllib.request import Request as _Req, urlopen as _urlopen
-        _body = _json.dumps({"p_api_key": api_key, "p_project_name": project}).encode()
-        _req = _Req(
-            f"{sb['SUPABASE_URL']}/rest/v1/rpc/mc_resolve_project",
-            data=_body,
-            method="POST",
-            headers={
-                "apikey": sb["SUPABASE_KEY"],
-                "Authorization": f"Bearer {sb['SUPABASE_KEY']}",
-                "Content-Type": "application/json",
-            },
-        )
-        with _urlopen(_req, timeout=10) as _resp:
-            _data = _json.loads(_resp.read().decode())
-            if isinstance(_data, dict) and _data.get("project_id"):
-                project_id = _data["project_id"]
-            elif isinstance(_data, dict) and _data.get("error"):
-                print(f"[meshcode] ERROR: could not resolve project '{project}': {_data['error']}", file=sys.stderr)
-                return 2
-    except Exception as _e:
-        print(f"[meshcode] WARNING: project_id resolution failed ({_e}); MCP server will retry at boot", file=sys.stderr)
-
-    os_name = platform.system()
-    config_path = CLIENT_CONFIG_PATHS[client].get(os_name)
-    if config_path is None:
-        print(f"[meshcode] ERROR: '{client}' is not supported on {os_name}", file=sys.stderr)
-        return 2
-
-    existing: Dict[str, Any] = {}
-    if config_path.exists():
-        try:
-            existing = json.loads(config_path.read_text())
-        except json.JSONDecodeError:
-            print(f"[meshcode] WARNING: {config_path} exists but is not valid JSON. Overwriting may break {CLIENT_DISPLAY_NAMES[client]}.", file=sys.stderr)
-            return 2
-
-    if not isinstance(existing, dict):
-        existing = {}
-
-    servers = existing.setdefault("mcpServers", {})
-    if not isinstance(servers, dict):
-        print(f"[meshcode] ERROR: 'mcpServers' in {config_path} is not an object", file=sys.stderr)
-        return 2
-
-    server_id = f"meshcode-{project}-{agent}"
-    servers[server_id] = {
-        "command": sys.executable or "python3",
-        "args": ["-m", "meshcode.meshcode_mcp", "serve"],
-        "env": {
-            "MESHCODE_PROJECT": project,
-            "MESHCODE_PROJECT_ID": project_id,
-            "MESHCODE_AGENT": agent,
-            "MESHCODE_ROLE": role or "MCP-connected agent",
-            "MESHCODE_API_KEY": api_key,
-            "SUPABASE_URL": sb["SUPABASE_URL"],
-            "SUPABASE_KEY": sb["SUPABASE_KEY"],
-        },
-    }
-
-    _atomic_write_json(config_path, existing)
-
-    display = CLIENT_DISPLAY_NAMES[client]
-    print(f"[meshcode] MCP server '{server_id}' added to {display} config")
-    print(f"[meshcode]   Path: {config_path}")
-    print(f"[meshcode]   Restart {display} to load the server.")
-    print(f"[meshcode]   Inside {display}, verify with /mcp — you should see '{server_id}' connected.")
-    print(f"[meshcode]   Tools: meshcode_send, meshcode_check, meshcode_read, meshcode_status, meshcode_set_status, ...")
-    return 0