meshcode 2.4.0__py3-none-any.whl → 2.4.2__py3-none-any.whl

meshcode/__init__.py

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

meshcode/cli.py

@@ -3,6 +3,17 @@
 import sys
 import os
 
+# Force UTF-8 on stdout/stderr for Windows terminals (cp1252 default crashes
+# on emojis, em-dashes, and any non-ASCII output the CLI prints).
+# Python 3.7+ supports reconfigure(); older versions get a no-op.
+try:
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+    if hasattr(sys.stderr, "reconfigure"):
+        sys.stderr.reconfigure(encoding="utf-8", errors="replace")
+except Exception:
+    pass
+
 
 def main():
     """Entry point that delegates to comms_v4.py within the package."""
@@ -18,7 +29,8 @@ def main():
             sys.argv[0] = candidate
             # Set __name__ and __file__ for the script
             globs = {"__name__": "__main__", "__file__": candidate}
-            with open(candidate) as f:
+            # Force UTF-8 on Windows (cp1252 default crashes on non-ASCII)
+            with open(candidate, encoding="utf-8") as f:
                 exec(compile(f.read(), candidate, "exec"), globs)
             return
 

meshcode/comms_v4.py

@@ -57,7 +57,7 @@ def _load_env_file():
         return {}
     out = {}
     try:
-        for line in env_path.read_text().splitlines():
+        for line in env_path.read_text(encoding="utf-8").splitlines():
             line = line.strip()
             if line.startswith("export "):
                 line = line[7:]
@@ -296,7 +296,7 @@ def can_nudge(project, name):
     nf = get_nudge_file(project, name)
     if nf and nf.exists():
         try:
-            last = float(nf.read_text().strip())
+            last = float(nf.read_text(encoding="utf-8").strip())
             if (time.time() - last) < NUDGE_COOLDOWN:
                 return False
         except (ValueError, IOError, OSError):
@@ -307,7 +307,7 @@ def can_nudge(project, name):
 def mark_nudged(project, name):
     nf = get_nudge_file(project, name)
     if nf:
-        nf.write_text(str(time.time()))
+        nf.write_text(str(time.time()), encoding="utf-8")
 
 
 def send_notification(project, name, from_agent, pending=1):
@@ -455,7 +455,7 @@ def _throttle_spawn_ok(project, name, max_per_5min=5):
     history = []
     if throttle_file.exists():
         try:
-            history = [float(x) for x in throttle_file.read_text().split() if x]
+            history = [float(x) for x in throttle_file.read_text(encoding="utf-8").split() if x]
         except Exception:
             history = []
     history = [t for t in history if now_ts - t < 300]  # last 5 min
@@ -463,7 +463,7 @@ def _throttle_spawn_ok(project, name, max_per_5min=5):
         return False
     history.append(now_ts)
     try:
-        throttle_file.write_text(" ".join(f"{t:.0f}" for t in history))
+        throttle_file.write_text(" ".join(f"{t:.0f}" for t in history), encoding="utf-8")
     except Exception:
         pass
     return True
@@ -615,7 +615,7 @@ def spawn_headless_agent(project, name, project_id, message_body, from_agent):
         ts_safe = started_iso.replace(":", "-").replace("+", "_")
         (debug_dir / f"{name}_{ts_safe}.log").write_text(
             f"=== SYSTEM PROMPT ===\n{system_prompt}\n\n=== USER MESSAGE ===\n{message_body}\n\n=== STDOUT ===\n{stdout_text}\n\n=== STDERR ===\n{stderr_text}\n"
-        )
+        , encoding="utf-8")
     except Exception:
         pass
     if exit_code != 0:
@@ -669,7 +669,7 @@ def nudge_agent(project, name, from_agent=""):
         return False
 
     try:
-        data = json.loads(session_file.read_text())
+        data = json.loads(session_file.read_text(encoding="utf-8"))
     except (json.JSONDecodeError, IOError, OSError):
         if _headless_spawn_allowed():
             log_msg(f"[{project}] NUDGE: {name} session file unreadable, spawning headless (opt-in)")
@@ -818,7 +818,7 @@ def get_session_info():
     for f in SESSIONS_DIR.iterdir():
         if f.is_file() and '_' in f.name and not f.name.startswith('.'):
             try:
-                data = json.loads(f.read_text())
+                data = json.loads(f.read_text(encoding="utf-8"))
                 session_tty = data.get("tty", "")
                 if session_tty and (session_tty in my_tty or my_tty in session_tty):
                     return data.get("project"), data.get("agent")
@@ -861,8 +861,15 @@ def register(project, name, role=""):
     except (subprocess.SubprocessError, OSError, ValueError):
         pass
 
-    # Register agent via tier-aware RPC (enforces plan limits)
-    rpc_result = sb_rpc("mc_register_agent", {
+    # Register agent via tier-aware RPC (enforces plan limits).
+    # Use with_api_key variant so scoped guest keys also work and so
+    # the RPC validates owner/member access (no anon bypass).
+    _api_key = _load_api_key_for_cli()
+    if not _api_key:
+        print("[ERROR] Not authenticated. Run `meshcode login <api_key>` first.")
+        return
+    rpc_result = sb_rpc("mc_register_agent_with_api_key", {
+        "p_api_key": _api_key,
         "p_project_id": project_id,
         "p_name": name,
         "p_role": role,
@@ -884,7 +891,7 @@ def register(project, name, role=""):
 
     # Save local session file (for nudge TTY detection)
     session_data = {"project": project, "agent": name, "pid": ppid, "tty": tty, "registered_at": now()}
-    (SESSIONS_DIR / f"{project}_{name}").write_text(json.dumps(session_data))
+    (SESSIONS_DIR / f"{project}_{name}").write_text(json.dumps(session_data), encoding="utf-8")
 
     # Get all agents in project
     agents = sb_select("mc_agents", f"project_id=eq.{project_id}", order="registered_at.asc")
@@ -1360,7 +1367,7 @@ def _start_heartbeat_daemon(project, name):
     # Stop any existing heartbeat
     try:
         if pid_file.exists():
-            old = int(pid_file.read_text().strip())
+            old = int(pid_file.read_text(encoding="utf-8").strip())
             try:
                 os.kill(old, 15)
             except Exception:
@@ -1389,12 +1396,17 @@ def _start_heartbeat_daemon(project, name):
         "    if pid: post('/rest/v1/rpc/mc_heartbeat', {'p_project_id':pid,'p_agent_name':name})\n"
         "    time.sleep(30)\n"
     )
-    proc = subprocess.Popen(
-        [sys.executable, "-c", code],
-        stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
-        start_new_session=True,
-    )
-    pid_file.write_text(str(proc.pid))
+    # Windows: start_new_session kwarg doesn't exist. Use creationflags.
+    _popen_kwargs = {
+        "stdout": subprocess.DEVNULL,
+        "stderr": subprocess.DEVNULL,
+    }
+    if sys.platform == "win32":
+        _popen_kwargs["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP
+    else:
+        _popen_kwargs["start_new_session"] = True
+    proc = subprocess.Popen([sys.executable, "-c", code], **_popen_kwargs)
+    pid_file.write_text(str(proc.pid), encoding="utf-8")
     return proc.pid
 
 
@@ -1402,7 +1414,7 @@ def _stop_heartbeat_daemon(project, name):
     pid_file = _heartbeat_loop_pidfile(project, name)
     if pid_file.exists():
         try:
-            pid = int(pid_file.read_text().strip())
+            pid = int(pid_file.read_text(encoding="utf-8").strip())
             os.kill(pid, 15)
         except Exception:
             pass
@@ -1426,13 +1438,18 @@ def connect_terminal(project, name, role=""):
     tty, owning = _capture_tty_for_pid(os.getppid())
     ppid = owning or os.getppid()
 
-    # Make sure agent identity exists (idempotent)
-    sb_rpc("mc_register_agent", {
-        "p_project_id": project_id,
-        "p_name": name,
-        "p_role": role,
-        "p_status": "needs_setup",
-    })
+    # Make sure agent identity exists (idempotent).
+    # Use with_api_key variant so scoped guest keys work and the RPC
+    # validates owner/member access (no anon bypass).
+    _api_key = _load_api_key_for_cli()
+    if _api_key:
+        sb_rpc("mc_register_agent_with_api_key", {
+            "p_api_key": _api_key,
+            "p_project_id": project_id,
+            "p_name": name,
+            "p_role": role,
+            "p_status": "needs_setup",
+        })
 
     rpc_result = sb_rpc("mc_connect_agent", {
         "p_project_id": project_id,
@@ -1445,7 +1462,7 @@ def connect_terminal(project, name, role=""):
         return
 
     session_data = {"project": project, "agent": name, "pid": ppid, "tty": tty, "registered_at": now()}
-    (SESSIONS_DIR / f"{project}_{name}").write_text(json.dumps(session_data))
+    (SESSIONS_DIR / f"{project}_{name}").write_text(json.dumps(session_data), encoding="utf-8")
 
     hb_pid = _start_heartbeat_daemon(project, name)
 
@@ -1503,7 +1520,7 @@ def connect(project, name, hook_target="claude", role=""):
     meta_path = Path.home() / ".meshcode" / "profile_meta.json"
     if meta_path.exists():
         try:
-            meta = json.loads(meta_path.read_text())
+            meta = json.loads(meta_path.read_text(encoding="utf-8"))
             print(f"[meshcode] Authenticated as {meta.get('display_name', meta.get('email', '?'))}")
         except Exception:
             pass
@@ -1534,7 +1551,7 @@ def connect(project, name, hook_target="claude", role=""):
             "send_command": f"python3 {comms_path} send {project} {name}:{{to}} '{{message}}'",
             "platform": os_name
         }
-        config_path.write_text(json.dumps(config, indent=2))
+        config_path.write_text(json.dumps(config, indent=2), encoding="utf-8")
         print(f"[meshcode] Config saved to {config_path}")
         print(f"[meshcode] Codex: use read_command and send_command from the config")
 
@@ -1591,7 +1608,7 @@ def login(api_key):
     config_dir = Path.home() / ".meshcode"
     config_dir.mkdir(exist_ok=True)
     meta_path = config_dir / "profile_meta.json"
-    meta_path.write_text(json.dumps(meta, indent=2))
+    meta_path.write_text(json.dumps(meta, indent=2), encoding="utf-8")
     try:
         os.chmod(meta_path, 0o600)
     except Exception:
@@ -1601,7 +1618,7 @@ def login(api_key):
     flag = config_dir / ".migrated_to_keychain"
     if not flag.exists():
         try:
-            flag.write_text("login")
+            flag.write_text("login", encoding="utf-8")
         except Exception:
             pass
 
@@ -1656,6 +1673,12 @@ ADMIN:
   unregister <proj> <name>                   Leave project
   prefs                                      View/set preferences
 
+PROFILES (multi-account):
+  profiles                                   List stored keychain profiles
+  --profile <name>                           Use a specific profile (global flag)
+  MESHCODE_PROFILE=<name>                    Env var equivalent
+  (Inside a workspace dir, profile is auto-detected from .mcp.json)
+
 FEATURES: Auto-status (5 states), Agent Replay, Live Spectator,
           Mesh Graph, Session Recording, Hot-reload
 
@@ -1843,6 +1866,31 @@ if __name__ == "__main__":
     for bf in _bare_present:
         flags[bf] = True
 
+    # Global --profile flag: selects which keychain profile api_key comes from.
+    # Priority: --profile <name> > MESHCODE_PROFILE env > "default".
+    # Sets MESHCODE_KEYCHAIN_PROFILE env so every downstream helper picks it up.
+    _profile_flag = flags.pop("profile", None)
+    if _profile_flag:
+        os.environ["MESHCODE_KEYCHAIN_PROFILE"] = _profile_flag
+    elif os.environ.get("MESHCODE_PROFILE") and not os.environ.get("MESHCODE_KEYCHAIN_PROFILE"):
+        os.environ["MESHCODE_KEYCHAIN_PROFILE"] = os.environ["MESHCODE_PROFILE"]
+    else:
+        # Auto-detect: if cwd is a meshcode workspace (~/meshcode/<proj>-<agent>),
+        # read its .mcp.json to find the profile baked in by setup.
+        try:
+            _cwd = Path.cwd()
+            _mcp_json = _cwd / ".mcp.json"
+            if _mcp_json.exists() and str(_cwd).startswith(str(Path.home() / "meshcode")):
+                _doc = json.loads(_mcp_json.read_text(encoding="utf-8"))
+                _servers = _doc.get("mcpServers", {}) or {}
+                for _sid, _sblk in _servers.items():
+                    _p = (_sblk.get("env") or {}).get("MESHCODE_KEYCHAIN_PROFILE")
+                    if _p and not os.environ.get("MESHCODE_KEYCHAIN_PROFILE"):
+                        os.environ["MESHCODE_KEYCHAIN_PROFILE"] = _p
+                        break
+        except Exception:
+            pass
+
     if cmd == "register":
         # Backwards-compat alias for `connect`. Mesh-only model: bind THIS
         # terminal to (project, agent) — never spawns claude.
@@ -1951,7 +1999,7 @@ if __name__ == "__main__":
             any_found = True
             agent = f.name[len(prefix):]
             try:
-                d = json.loads(f.read_text())
+                d = json.loads(f.read_text(encoding="utf-8"))
             except Exception as e:
                 print(f"  [{agent}] CORRUPT ({e})")
                 continue
@@ -2053,12 +2101,28 @@ if __name__ == "__main__":
 
     elif cmd in ("run", "go"):
         # meshcode go <agent> [--project <name>] [--editor claude|cursor|code]
+        # meshcode go <project>/<agent> — disambiguation syntax when same agent
+        #   name exists in multiple meshworks
         # meshcode run <agent> (backwards compat, same as go)
         if len(sys.argv) < 3:
             print(f"Usage: meshcode {cmd} <agent> [--project <name>] [--editor claude|cursor|code]")
+            print(f"   or: meshcode {cmd} <project>/<agent>  (disambiguation)")
             sys.exit(1)
-        agent = sys.argv[2]
-        proj_override = flags.get("project")
+        agent_arg = sys.argv[2]
+        # Parse project/agent syntax
+        if "/" in agent_arg and not agent_arg.startswith("/"):
+            parts = agent_arg.split("/", 1)
+            if len(parts) == 2 and parts[0] and parts[1]:
+                proj_override = parts[0]
+                agent = parts[1]
+            else:
+                agent = agent_arg
+                proj_override = flags.get("project")
+        else:
+            agent = agent_arg
+            proj_override = flags.get("project")
+        if flags.get("project"):
+            proj_override = flags.get("project")
         editor_override = flags.get("editor")
         perm_override = flags.get("permission")  # bypass | safe | ask
         if "--bypass" in sys.argv:
@@ -2149,6 +2213,47 @@ if __name__ == "__main__":
             sys.exit(1)
         login(key)
 
+    elif cmd in ("profiles", "whoami"):
+        # List all stored keychain profiles with metadata
+        try:
+            import importlib as _il
+            _sec = _il.import_module("meshcode.secrets")
+        except Exception as _e:
+            print(f"[meshcode] ERROR: cannot load secrets module: {_e}", file=sys.stderr)
+            sys.exit(1)
+
+        profiles = _sec.list_profiles()
+        active = os.environ.get("MESHCODE_KEYCHAIN_PROFILE") or "default"
+
+        if not profiles:
+            print("[meshcode] No profiles stored yet.")
+            print("[meshcode] Run `meshcode login <api_key>` to create the default profile,")
+            print("[meshcode] or `meshcode join <invite-token>` to create a scoped profile.")
+            sys.exit(0)
+
+        print()
+        print(f"[meshcode] Stored profiles ({len(profiles)}):")
+        print()
+        for name, meta in sorted(profiles.items()):
+            marker = " *ACTIVE*" if name == active else ""
+            kind = meta.get("type", "default" if name == "default" else "scoped")
+            print(f"  {name}{marker}")
+            print(f"      type: {kind}")
+            if meta.get("meshwork"):
+                print(f"      meshwork: {meta['meshwork']}")
+            if meta.get("agent"):
+                print(f"      agent: {meta['agent']}")
+            if meta.get("email"):
+                print(f"      email: {meta['email']}")
+            if meta.get("expires_at"):
+                print(f"      expires: {meta['expires_at']}")
+            if meta.get("backend"):
+                print(f"      backend: {meta['backend']}")
+        print()
+        print("[meshcode] Use `--profile <name>` or `MESHCODE_PROFILE=<name>` to switch.")
+        print("[meshcode] In a meshcode workspace dir, the profile is auto-detected from .mcp.json.")
+        sys.exit(0)
+
     elif cmd == "prefs":
         # meshcode prefs permission-mode [bypass|safe|ask]   (no arg = show)
         # meshcode prefs auto-update [on|off|reset]          (no arg = show)

meshcode/invites.py

@@ -79,10 +79,17 @@ def _rpc(name: str, body: Dict[str, Any]) -> Optional[Dict[str, Any]]:
 
 
 def _get_default_api_key() -> Optional[str]:
+    """Read the api key for the active profile.
+
+    Profile resolution: MESHCODE_KEYCHAIN_PROFILE env > "default".
+    The CLI dispatcher sets MESHCODE_KEYCHAIN_PROFILE from --profile flag,
+    MESHCODE_PROFILE env, or workspace auto-detection.
+    """
     try:
         import importlib
         secrets_mod = importlib.import_module("meshcode.secrets")
-        return secrets_mod.get_api_key(profile="default")
+        profile = os.environ.get("MESHCODE_KEYCHAIN_PROFILE") or "default"
+        return secrets_mod.get_api_key(profile=profile)
     except Exception:
         return None
 
@@ -165,15 +172,28 @@ def cmd_join(token: str, display_name: Optional[str] = None) -> int:
     if not isinstance(redeem, dict):
         print("[meshcode] ERROR: could not redeem invite", file=sys.stderr)
         return 1
+    # Handle both application errors ({"error": "..."}) and Postgres errors
+    # ({"code": "42703", "message": "...", "details": ..., "hint": ...})
     if redeem.get("error"):
         print(f"[meshcode] ERROR: {redeem['error']}", file=sys.stderr)
         return 1
+    if redeem.get("code") and redeem.get("message"):
+        print(f"[meshcode] ERROR: database error {redeem['code']}: {redeem['message']}", file=sys.stderr)
+        if redeem.get("hint"):
+            print(f"[meshcode]   hint: {redeem['hint']}", file=sys.stderr)
+        return 1
 
     scoped_key = redeem.get("api_key")
-    project = redeem.get("meshwork")
+    # Backend returns both "project_name" (canonical) and "meshwork" (legacy)
+    project = redeem.get("project_name") or redeem.get("meshwork")
     agent = redeem.get("agent_name")
     if not scoped_key or not project or not agent:
-        print("[meshcode] ERROR: redeem succeeded but response was incomplete", file=sys.stderr)
+        missing = []
+        if not scoped_key: missing.append("api_key")
+        if not project: missing.append("project_name/meshwork")
+        if not agent: missing.append("agent_name")
+        print(f"[meshcode] ERROR: redeem succeeded but response missing fields: {', '.join(missing)}", file=sys.stderr)
+        print(f"[meshcode]   got keys: {sorted(redeem.keys())}", file=sys.stderr)
         return 1
 
     # 3. Store scoped key in OS keychain under a per-mesh profile

meshcode/launcher.py

@@ -67,7 +67,7 @@ def load_env() -> tuple[str, str]:
     key = os.environ.get("SUPABASE_KEY", "").strip()
     if not (url and key) and ENV_FILE.exists():
         try:
-            for raw in ENV_FILE.read_text().splitlines():
+            for raw in ENV_FILE.read_text(encoding="utf-8").splitlines():
                 line = raw.strip()
                 if not line or line.startswith("#"):
                     continue
@@ -103,7 +103,7 @@ def write_pidfile() -> None:
         "uptime_seconds": int(time.time() - _start_time),
     }
     try:
-        PID_FILE.write_text(json.dumps(payload, indent=2))
+        PID_FILE.write_text(json.dumps(payload, indent=2), encoding="utf-8")
     except Exception as e:
         log(f"pid-file write failed: {e}", err=True)
 

meshcode/meshcode_mcp/server.py

@@ -885,8 +885,18 @@ def meshcode_send(to: str, message: Any, in_reply_to: Optional[str] = None,
 
 @mcp.tool()
 @with_working_status
-def meshcode_broadcast(payload: Dict[str, Any]) -> Dict[str, Any]:
-    """Broadcast to ALL agents in this meshwork (except yourself)."""
+def meshcode_broadcast(payload: Any) -> Dict[str, Any]:
+    """Broadcast to ALL agents in this meshwork (except yourself).
+
+    Accepts payload as either:
+      - dict (structured): {"type": "...", "detail": "..."}
+      - str (shorthand): wrapped internally as {"text": "..."}
+    """
+    if isinstance(payload, str):
+        payload = {"text": payload}
+    elif not isinstance(payload, dict):
+        return {"error": "payload must be a string or object", "got_type": type(payload).__name__}
+
     agents = be.get_board(_PROJECT_ID)
     sent = 0
     for a in agents:

meshcode/run_agent.py

@@ -44,7 +44,9 @@ def _try_auto_setup(agent: str, project: Optional[str] = None) -> Optional[Tuple
     except Exception:
         return None
 
-    api_key = secrets_mod.get_api_key(profile="default")
+    import os as _os
+    profile = _os.environ.get("MESHCODE_KEYCHAIN_PROFILE") or "default"
+    api_key = secrets_mod.get_api_key(profile=profile)
     if not api_key:
         return None
 

meshcode/self_update.py

@@ -144,7 +144,7 @@ def consume_pending_result() -> None:
     if not RESULT_PATH.exists():
         return
     try:
-        data = json.loads(RESULT_PATH.read_text())
+        data = json.loads(RESULT_PATH.read_text(encoding="utf-8"))
         RESULT_PATH.unlink(missing_ok=True)
     except Exception:
         return
@@ -188,7 +188,7 @@ def _acquire_lock() -> bool:
                 return False
             LOCK_PATH.unlink(missing_ok=True)
         LOCK_PATH.parent.mkdir(parents=True, exist_ok=True)
-        LOCK_PATH.write_text(str(os.getpid()))
+        LOCK_PATH.write_text(str(os.getpid()), encoding="utf-8")
         return True
     except Exception:
         return False
@@ -233,7 +233,7 @@ except Exception as e:
 finally:
     result["finished_at"] = int(time.time())
     try:
-        result_path.write_text(json.dumps(result))
+        result_path.write_text(json.dumps(result), encoding="utf-8")
     except Exception:
         pass
     try:

meshcode/setup_clients.py

@@ -53,7 +53,7 @@ def _load_credentials(profile: str = "default") -> Dict[str, str]:
     meta: Dict[str, Any] = {"api_key": api_key}
     if meta_path.exists():
         try:
-            extra = json.loads(meta_path.read_text())
+            extra = json.loads(meta_path.read_text(encoding="utf-8"))
             if isinstance(extra, dict):
                 meta.update({k: v for k, v in extra.items() if v is not None})
         except Exception:
@@ -64,7 +64,7 @@ def _load_credentials(profile: str = "default") -> Dict[str, str]:
     legacy_path = Path.home() / ".meshcode" / "credentials.json"
     if legacy_path.exists() and not meta_path.exists():
         try:
-            legacy = json.loads(legacy_path.read_text())
+            legacy = json.loads(legacy_path.read_text(encoding="utf-8"))
             if isinstance(legacy, dict):
                 for k in ("user_id", "email", "display_name"):
                     if legacy.get(k) and not meta.get(k):
@@ -81,7 +81,7 @@ def _load_supabase_env() -> Dict[str, str]:
     if not url or not key:
         env_file = Path.home() / ".meshcode" / "env"
         if env_file.exists():
-            for line in env_file.read_text().splitlines():
+            for line in env_file.read_text(encoding="utf-8").splitlines():
                 line = line.strip()
                 if line.startswith("export "):
                     line = line[7:]
@@ -204,7 +204,7 @@ def _build_server_block(project: str, project_id: str, agent: str, role: str,
 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.write_text(json.dumps(data, indent=2), encoding="utf-8")
     tmp.replace(path)
 
 
@@ -258,7 +258,7 @@ def _atomic_write_toml_codex(path: Path, server_id: str, server_block: Dict[str,
     Atomic via tempfile + replace.
     """
     path.parent.mkdir(parents=True, exist_ok=True)
-    text = path.read_text() if path.exists() else ""
+    text = path.read_text(encoding="utf-8") if path.exists() else ""
 
     quoted = f'"{_toml_escape(server_id)}"'
     header = f"[mcp_servers.{quoted}]"
@@ -291,7 +291,7 @@ def _atomic_write_toml_codex(path: Path, server_id: str, server_block: Dict[str,
     new_text += _render_codex_block(server_id, server_block)
 
     tmp = path.with_suffix(path.suffix + ".tmp")
-    tmp.write_text(new_text)
+    tmp.write_text(new_text, encoding="utf-8")
     tmp.replace(path)
 
 
@@ -306,7 +306,7 @@ def _write_continue_config(ws: Path, server_id: str, server_block: Dict[str, Any
     args = server_block.get("args", [])
 
     # Build YAML manually (no yaml dependency)
-    lines = ["# MeshCode MCP server — auto-generated by meshcode setup"]
+    lines = ["# MeshCode MCP server - auto-generated by meshcode setup"]
     lines.append("models: []")
     lines.append("mcpServers:")
     lines.append(f"  - name: {server_id}")
@@ -323,7 +323,7 @@ def _write_continue_config(ws: Path, server_id: str, server_block: Dict[str, Any
     config_dir.mkdir(parents=True, exist_ok=True)
     config_path = config_dir / "config.yaml"
     try:
-        config_path.write_text("\n".join(lines) + "\n")
+        config_path.write_text("\n".join(lines) + "\n", encoding="utf-8")
     except (IOError, OSError) as e:
         print(f"[meshcode] WARNING: could not write Continue config: {e}", file=sys.stderr)
 
@@ -423,7 +423,7 @@ def setup_workspace(project: str, agent: str, role: str = "",
     registry: Dict[str, Any] = {}
     if registry_path.exists():
         try:
-            registry = json.loads(registry_path.read_text())
+            registry = json.loads(registry_path.read_text(encoding="utf-8"))
         except Exception:
             registry = {}
     registry.setdefault("agents", {})[agent] = {
@@ -463,7 +463,7 @@ This is your workspace dir — feel free to scaffold any files your task needs h
 work in a different repo by `cd`ing elsewhere after launch.
 """
     try:
-        (ws / "README.md").write_text(readme_body)
+        (ws / "README.md").write_text(readme_body, encoding="utf-8")
     except Exception as _e:
         print(f"[meshcode] WARNING: could not write README.md: {_e}", file=sys.stderr)
 
@@ -567,7 +567,7 @@ def setup_global(client: str, project: str, agent: str, role: str = "") -> int:
         existing: Dict[str, Any] = {}
         if config_path.exists():
             try:
-                existing = json.loads(config_path.read_text())
+                existing = json.loads(config_path.read_text(encoding="utf-8"))
             except json.JSONDecodeError:
                 print(f"[meshcode] WARNING: {config_path} exists but is not valid JSON.", file=sys.stderr)
                 return 2

{meshcode-2.4.0.dist-info → meshcode-2.4.2.dist-info}/METADATA

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

{meshcode-2.4.0.dist-info → meshcode-2.4.2.dist-info}/RECORD

@@ -1,25 +1,25 @@
-meshcode/__init__.py,sha256=P1Cz8G5O-3maP25kkOKpt2HysDxZRijr-GrPlKdMjKU,84
-meshcode/cli.py,sha256=0_QKzkNr4VPwRyfEGQ7R_rb9--qxEGeZ8XNXqA4R9Tg,922
-meshcode/comms_v4.py,sha256=8vZ6Z6xE-jcLn12dvjs0F5VR78TfdAC5GKnOR_vdXEI,88041
-meshcode/invites.py,sha256=eltXeL1ycplsZXk8FRl4dAIwTvRq8wgowwIxHRehMWc,13530
-meshcode/launcher.py,sha256=tCMD8ExwtN2ogPqSJ7Xp2Dt6w-EpD9pg7zS0kM8eLLw,12095
+meshcode/__init__.py,sha256=qB8hIuwmMwgqGtGO8uzgyFNbZAvLm4XVrhaj4QjLR1Y,84
+meshcode/cli.py,sha256=zHVYBoj7EIx6J_rxgsALT9bqr1YAIPU9yUVdCRwpP0g,1477
+meshcode/comms_v4.py,sha256=yhsNF8aVFjBI0w_mO4jOyz3W60HoxzcP7eQyd2Kkvos,93426
+meshcode/invites.py,sha256=TWN5dAPrKBhBKzWQ_e4nzwW5QmiBd7mxd1RwjLWr7go,14690
+meshcode/launcher.py,sha256=qoU3yOdvMtqWxHduhqDIJ_iXjT3CeDIScwfVX2osfhM,12129
 meshcode/launcher_install.py,sha256=79MVxHtskmcJYGCRM8aU4wIxjExgEHmTL3Xhmi_e3n0,13143
 meshcode/preferences.py,sha256=loIu-t8zJJLFbjz8smXdZbe1SFFxk_GOowLc3haSavk,8536
 meshcode/protocol_v2.py,sha256=Qi-Lj_fOwCupOEdh-bzQLXE7qlzW-2YCLN3yGEOfiPY,3517
-meshcode/run_agent.py,sha256=f-yWVjyTfV2H3jZTDb2Mp7hD0A296P-idLDlbSk9OMg,11304
+meshcode/run_agent.py,sha256=s4nccjkzOMYF-b0eT0RgNRRvFHbv7rgFPIViY01M3VM,11395
 meshcode/secrets.py,sha256=IaYL2nP8jZzryjB36oM4JKc6lFMyUZYf5qhJwOzihEY,12663
-meshcode/self_update.py,sha256=Exvzgv5WK1ygGkM6bAdzwP7_VPEl5RzhBaJmDKus9Ag,11156
-meshcode/setup_clients.py,sha256=McFscPisuS_t5bS31C1rV5_wRh7VmwAcMDuo1KJPl80,27950
+meshcode/self_update.py,sha256=Id1O4s4UOuR9AnOD7IIquyizQcKH1cmkgjZuvrvqK00,11208
+meshcode/setup_clients.py,sha256=OEwZz-ydtkVbRRxxyRCYx9nSb1fhCwaG6kvZEMEHllQ,28116
 meshcode/meshcode_mcp/__init__.py,sha256=OdzyVP8YHG4BaSuUvVAOy7FgGp6og2vOVbyV_Iuz3pE,110
 meshcode/meshcode_mcp/__main__.py,sha256=rrnTlA7ciA_C6b5QlbKlQli6O4vPEJRksCoeLIj8k1Q,1533
 meshcode/meshcode_mcp/backend.py,sha256=gglWwJ47wt66LlyFitlmc2Bc6Xc-NYr814g7FBof0nE,14414
 meshcode/meshcode_mcp/realtime.py,sha256=nglDB813psFAhEfUxp6vESH-CUD_T1mQzA9qCCRTPKU,9525
-meshcode/meshcode_mcp/server.py,sha256=JbP9Os5_57Na6KPm0Z0872MW0BUsxMBZQP2nqyMPx4A,61070
+meshcode/meshcode_mcp/server.py,sha256=wIdaLFPN_bZ01ojet44ye7JtEb4xSO6xSkYGv_ZEYPo,61428
 meshcode/meshcode_mcp/test_backend.py,sha256=B-J__pStnN4vVBzYN4yz2CKRylwDz09ZJbj4RVUtpr0,3101
 meshcode/meshcode_mcp/test_realtime.py,sha256=g2V3QzumdZgus4-b2Q-3bPFwX5Ib7BuzYah_vUrOAOU,3254
 meshcode/meshcode_mcp/test_server_wrapper.py,sha256=ohbKkfN_k-ApElnnOxSx4_y5lWwUBM3urfm8JndOloM,4464
-meshcode-2.4.0.dist-info/METADATA,sha256=qBbRTwZRAU4OyEPbhNRxr_3jFjjXg__iy_8W27QxvQU,15353
-meshcode-2.4.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-meshcode-2.4.0.dist-info/entry_points.txt,sha256=-sX1FVOjMA-96Rt4GDCFCyFRGjAuYJSgXkBpWnDfShA,98
-meshcode-2.4.0.dist-info/top_level.txt,sha256=M_cv_gd_8ojgYoHk9qOCaDmmX47ypozEOYKtQvm03H8,9
-meshcode-2.4.0.dist-info/RECORD,,
+meshcode-2.4.2.dist-info/METADATA,sha256=jvhPUKsADXoYVcAmxFKxLsquGwylehA3kmZXNGWL7b8,15353
+meshcode-2.4.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+meshcode-2.4.2.dist-info/entry_points.txt,sha256=-sX1FVOjMA-96Rt4GDCFCyFRGjAuYJSgXkBpWnDfShA,98
+meshcode-2.4.2.dist-info/top_level.txt,sha256=M_cv_gd_8ojgYoHk9qOCaDmmX47ypozEOYKtQvm03H8,9
+meshcode-2.4.2.dist-info/RECORD,,