meshcode 2.10.40__tar.gz → 2.10.41__tar.gz

{meshcode-2.10.40 → meshcode-2.10.41}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.10.40
+Version: 2.10.41
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT
@@ -400,10 +400,32 @@ meshcode projects                       # lists all your meshworks
 **8. Unknown command (e.g., `meshcode list`)**
 Since v2.0.2, the CLI suggests the closest match instead of dumping the full help text. Common aliases: `list` and `ls` both work for `projects`.
 
-**5. `MCP server failed to start` in the Claude Code `/mcp` panel**
+**9. Windows: agent registers but never appears online**
+On Windows, especially with Python 3.14+, you may see `ImportError` crashes or agents that register but stay offline. This was fixed in v2.10.40. Upgrade first:
+```bash
+pip install meshcode --upgrade
+```
+If the agent still fails after upgrading, check that your `.mcp.json` command path is valid. On Windows, the MCP config should use `python` (not `python3`, which doesn't exist on Windows):
+```json
+{
+  "command": "python",
+  "args": ["-m", "meshcode_mcp", "serve"]
+}
+```
+If `meshcode setup` was run from a conda/venv environment that no longer exists, the baked path in `.mcp.json` will be stale. Re-run `meshcode setup <project> <agent>` from your current Python environment to fix it.
+
+As a fast-path workaround, you can set `MESHCODE_PROJECT_ID` as an environment variable to bypass the project name lookup at boot (which can fail on Windows due to RLS visibility):
+```bash
+set MESHCODE_PROJECT_ID=your-project-uuid   # Windows cmd
+$env:MESHCODE_PROJECT_ID="your-project-uuid"  # Windows PowerShell
+```
+
+You can also run `meshcode doctor` (v2.10.41+) to diagnose stale paths, missing dependencies, and config issues across all your workspaces.
+
+**10. `MCP server failed to start` in the Claude Code `/mcp` panel**
 Run `claude --debug` to see the underlying error. Nine times out of ten it's a stale or missing key — run `meshcode login mc_xxx` again.
 
-**6. PyPI says `Could not find version 1.x.x` immediately after a publish**
+**11. PyPI says `Could not find version 1.x.x` immediately after a publish**
 CDN propagation. Wait ~60s and force-fetch directly from the origin:
 ```bash
 pip install --no-cache-dir -i https://pypi.org/simple/ meshcode

{meshcode-2.10.40 → meshcode-2.10.41}/README.md

@@ -374,10 +374,32 @@ meshcode projects                       # lists all your meshworks
 **8. Unknown command (e.g., `meshcode list`)**
 Since v2.0.2, the CLI suggests the closest match instead of dumping the full help text. Common aliases: `list` and `ls` both work for `projects`.
 
-**5. `MCP server failed to start` in the Claude Code `/mcp` panel**
+**9. Windows: agent registers but never appears online**
+On Windows, especially with Python 3.14+, you may see `ImportError` crashes or agents that register but stay offline. This was fixed in v2.10.40. Upgrade first:
+```bash
+pip install meshcode --upgrade
+```
+If the agent still fails after upgrading, check that your `.mcp.json` command path is valid. On Windows, the MCP config should use `python` (not `python3`, which doesn't exist on Windows):
+```json
+{
+  "command": "python",
+  "args": ["-m", "meshcode_mcp", "serve"]
+}
+```
+If `meshcode setup` was run from a conda/venv environment that no longer exists, the baked path in `.mcp.json` will be stale. Re-run `meshcode setup <project> <agent>` from your current Python environment to fix it.
+
+As a fast-path workaround, you can set `MESHCODE_PROJECT_ID` as an environment variable to bypass the project name lookup at boot (which can fail on Windows due to RLS visibility):
+```bash
+set MESHCODE_PROJECT_ID=your-project-uuid   # Windows cmd
+$env:MESHCODE_PROJECT_ID="your-project-uuid"  # Windows PowerShell
+```
+
+You can also run `meshcode doctor` (v2.10.41+) to diagnose stale paths, missing dependencies, and config issues across all your workspaces.
+
+**10. `MCP server failed to start` in the Claude Code `/mcp` panel**
 Run `claude --debug` to see the underlying error. Nine times out of ten it's a stale or missing key — run `meshcode login mc_xxx` again.
 
-**6. PyPI says `Could not find version 1.x.x` immediately after a publish**
+**11. PyPI says `Could not find version 1.x.x` immediately after a publish**
 CDN propagation. Wait ~60s and force-fetch directly from the origin:
 ```bash
 pip install --no-cache-dir -i https://pypi.org/simple/ meshcode

{meshcode-2.10.40 → meshcode-2.10.41}/meshcode/__init__.py

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

{meshcode-2.10.40 → meshcode-2.10.41}/meshcode/comms_v4.py

@@ -343,9 +343,26 @@ def _is_pid_alive(pid):
     if not pid:
         return False
     try:
-        os.kill(int(pid), 0)
+        pid = int(pid)
+    except (ValueError, TypeError):
+        return False
+    if sys.platform == "win32":
+        # os.kill(pid, 0) doesn't work on Windows — use kernel32 OpenProcess
+        try:
+            import ctypes
+            PROCESS_QUERY_LIMITED_INFORMATION = 0x1000
+            handle = ctypes.windll.kernel32.OpenProcess(
+                PROCESS_QUERY_LIMITED_INFORMATION, False, pid)
+            if handle:
+                ctypes.windll.kernel32.CloseHandle(handle)
+                return True
+            return False
+        except Exception:
+            return False
+    try:
+        os.kill(pid, 0)
         return True
-    except (OSError, ValueError, TypeError):
+    except OSError:
         return False
 
 
@@ -533,7 +550,7 @@ def spawn_headless_agent(project, name, project_id, message_body, from_agent):
         f"{message_body}\n\n"
         f"Recent mesh activity:\n{history_text or '(none)'}\n\n"
         "Process the message. If you need to reply, use this exact bash command (one line):\n"
-        f"  SUPABASE_URL=\"$SUPABASE_URL\" SUPABASE_KEY=\"$SUPABASE_KEY\" python3 ~/Desktop/meshcode/comms_v4.py send {project} {name}:{from_agent} '<json_response>'\n\n"
+        f"  {sys.executable} -m meshcode send {project} {name}:{from_agent} '<json_response>'\n\n"
         "Then exit. Do not start a long conversation."
     )
 
@@ -579,7 +596,8 @@ def spawn_headless_agent(project, name, project_id, message_body, from_agent):
         claude_bin = _find_claude()
         # Augment PATH so any subprocess the agent itself spawns (git, npm,
         # python3, supabase CLI, etc.) can find common tools.
-        env["PATH"] = "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:" + env.get("PATH", "")
+        if sys.platform != "win32":
+            env["PATH"] = "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:" + env.get("PATH", "")
         result = subprocess.run(
             [claude_bin, "--print", "--dangerously-skip-permissions",
              "--append-system-prompt", system_prompt, message_body or ""],
@@ -959,12 +977,34 @@ def register(project, name, role=""):
     log_msg(f"{name} joined {project} (tty={tty}, backend=supabase)")
 
 
+def _resolve_agent_name(project_id, name):
+    """Resolve partial agent name to full registered name."""
+    if not name or name == "*":
+        return name
+    agents = sb_select("mc_agents", f"project_id=eq.{project_id}", limit=50)
+    if not agents:
+        return name
+    all_names = [a["name"] for a in agents]
+    if name in all_names:
+        return name
+    prefix = [n for n in all_names if n.startswith(name)]
+    if len(prefix) == 1:
+        return prefix[0]
+    sub = [n for n in all_names if name in n]
+    if len(sub) == 1:
+        return sub[0]
+    return name
+
+
 def send_msg(project, from_agent, to_agent, content, msg_type="msg", compact=False):
     project_id = get_project_id(project)
     if not project_id:
         print(f"[ERROR] Proyecto '{project}' no encontrado")
         return
 
+    # Resolve partial agent names
+    to_agent = _resolve_agent_name(project_id, to_agent)
+
     payload = {}
     try:
         payload = json.loads(content)
@@ -1026,7 +1066,7 @@ def broadcast(project, from_agent, content, msg_type="broadcast"):
     print(f"[{project}] broadcast from {from_agent} -> {count} agents")
 
 
-def read_messages(project, name, silent=False):
+def read_messages(project, name, silent=False, send_acks=True):
     project_id = get_project_id(project)
     if not project_id:
         if not silent:
@@ -1064,21 +1104,68 @@ def read_messages(project, name, silent=False):
             ack_targets.add(sender)
     print("---")
 
-    # Send automatic ACKs
-    for sender in ack_targets:
-        ack_payload = {"text": f"{name} read your message"}
-        sb_insert("mc_messages", {
-            "project_id": project_id,
-            "from_agent": name,
-            "to_agent": sender,
-            "type": "ack",
-            "payload": ack_payload,
-            "read": False
-        })
+    # Send automatic ACKs (skip when called from watch to avoid ack spam)
+    if send_acks:
+        for sender in ack_targets:
+            ack_payload = {"text": f"{name} read your message"}
+            sb_insert("mc_messages", {
+                "project_id": project_id,
+                "from_agent": name,
+                "to_agent": sender,
+                "type": "ack",
+                "payload": ack_payload,
+                "read": True
+            })
 
     return messages
 
 
+def inbox(project, name):
+    """All-in-one: show agent status, pending count, tasks, and read new messages."""
+    project_id = get_project_id(project)
+    if not project_id:
+        print(f"[meshcode] Project '{project}' not found")
+        return
+
+    # Agent status
+    agent_rows = sb_select("mc_agents",
+        f"project_id=eq.{project_id}&name=eq.{quote(name)}", limit=1)
+    if agent_rows:
+        a = agent_rows[0]
+        print(f"[{project}] {name} | status: {a.get('status', '?')} | task: {a.get('task', '-')}")
+    else:
+        print(f"[{project}] {name} (not registered)")
+
+    # Pending messages
+    pending = sb_select("mc_messages",
+        f"project_id=eq.{project_id}&to_agent=eq.{quote(name)}&read=eq.false&type=neq.ack",
+        order="created_at.asc")
+    if pending:
+        print(f"\n  {len(pending)} unread message(s):")
+        for msg in pending:
+            sender = msg["from_agent"]
+            ts = msg.get("created_at", "")
+            if "T" in ts:
+                ts = ts.replace("T", " ")[:19]
+            payload = msg.get("payload", {})
+            preview = json.dumps(payload, ensure_ascii=False)[:100]
+            print(f"    [{ts}] {sender}: {preview}")
+        # Ask if they want to read (mark as read)
+        print(f"\n  Run `meshcode read {project} {name}` to read and mark as read.")
+    else:
+        print("  No unread messages.")
+
+    # Open tasks assigned to this agent
+    tasks = sb_select("mc_tasks",
+        f"project_id=eq.{project_id}&assignee=eq.{quote(name)}&status=neq.done&status=neq.canceled",
+        order="created_at.desc", limit=5)
+    if tasks:
+        print(f"\n  {len(tasks)} open task(s):")
+        for t in tasks:
+            print(f"    [{t.get('priority', '?')}] {t.get('title', '?')} ({t.get('status', '?')})")
+    print()
+
+
 def hook_check():
     """Called by PostToolUse hook. Auto-detects project+agent, prints pending.
     Also sends heartbeat so dashboard always shows fresh status."""
@@ -1127,7 +1214,10 @@ def watch(project, name, interval=10, timeout=0):
             f"project_id=eq.{project_id}&name=eq.{quote(name)}",
             {"status": "online", "task": "Listening to user", "last_heartbeat": now_iso()})
         sys.exit(0)
-    signal.signal(signal.SIGINT, handle_interrupt)
+    try:
+        signal.signal(signal.SIGINT, handle_interrupt)
+    except ValueError:
+        pass  # Non-main thread (Windows restriction)
 
     # Update status to standby
     sb_update("mc_agents",
@@ -1148,13 +1238,18 @@ def watch(project, name, interval=10, timeout=0):
             if pending:
                 elapsed = int(time.time() - start)
                 print(f"\n*** [{project.upper()}] MENSAJE RECIBIDO ({elapsed}s en standby) ***")
-                messages = read_messages(project, name, silent=False)
+                read_messages(project, name, silent=False, send_acks=False)
 
                 sb_update("mc_agents",
                     f"project_id=eq.{project_id}&name=eq.{quote(name)}",
                     {"status": "working", "task": "Procesando mensaje recibido", "last_heartbeat": now_iso()})
 
-                return messages
+                # Reset to standby and keep polling (don't exit the loop)
+                time.sleep(2)
+                sb_update("mc_agents",
+                    f"project_id=eq.{project_id}&name=eq.{quote(name)}",
+                    {"status": "standby", "task": "Waiting for messages...", "last_heartbeat": now_iso()})
+                continue
 
             # Heartbeat
             sb_rpc("mc_heartbeat", {"p_project_id": project_id, "p_agent_name": name})
@@ -1181,7 +1276,7 @@ def update_board(project, name, status, task=""):
             count = len(sb_select("mc_messages",
                 f"project_id=eq.{project_id}&to_agent=eq.{quote(name)}&read=eq.false&type=neq.ack"))
             print(f"[{project}] {name}: NO puedes estar idle — tienes {count} mensaje(s) pendientes.")
-            print(f"[{project}] Ejecuta: python3 ~/Desktop/meshcode/comms_v4.py read {project} {name}")
+            print(f"[{project}] Ejecuta: {sys.executable} -m meshcode read {project} {name}")
             status = "working"
             task = f"{count} pending messages"
 
@@ -1215,13 +1310,21 @@ def show_board(project):
 
 
 def show_status(project=None):
-    if project:
+    # Try API-key-authenticated RPC first (RLS may block anon SELECT)
+    api_key = _load_api_key_for_cli()
+    if api_key and not project:
+        rpc_data = sb_rpc("mc_list_user_projects", {"p_api_key": api_key})
+        if isinstance(rpc_data, dict) and not rpc_data.get("error"):
+            projects_data = rpc_data.get("projects", [])
+        else:
+            projects_data = sb_select("mc_projects", "", order="created_at.asc")
+    elif project:
         projects_data = sb_select("mc_projects", f"name=eq.{quote(project)}")
     else:
         projects_data = sb_select("mc_projects", "", order="created_at.asc")
 
     if not projects_data:
-        print("[COMMS] No active projects")
+        print("[meshcode] No projects found. Try `meshcode projects` or `meshcode login <api_key>` first.")
         return
 
     print(f"\n{'='*60}")
@@ -1398,7 +1501,7 @@ def _start_heartbeat_daemon(project, name):
         if pid_file.exists():
             old = int(pid_file.read_text(encoding="utf-8").strip())
             try:
-                os.kill(old, 15)
+                _terminate_pid(old)
             except Exception:
                 pass
     except Exception:
@@ -1450,12 +1553,21 @@ def _start_heartbeat_daemon(project, name):
     return proc.pid
 
 
+def _terminate_pid(pid):
+    """Terminate a process by PID, cross-platform."""
+    if sys.platform == "win32":
+        subprocess.run(["taskkill", "/F", "/PID", str(pid)],
+                       stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    else:
+        os.kill(pid, 15)
+
+
 def _stop_heartbeat_daemon(project, name):
     pid_file = _heartbeat_loop_pidfile(project, name)
     if pid_file.exists():
         try:
             pid = int(pid_file.read_text(encoding="utf-8").strip())
-            os.kill(pid, 15)
+            _terminate_pid(pid)
         except Exception:
             pass
         try:
@@ -1603,19 +1715,11 @@ def connect(project, name, hook_target="claude", role=""):
         _setup_ws(project, name, actual_role)
 
     elif hook_target == "codex":
-        config_path = Path.cwd() / ".meshcode.json"
-        config = {
-            "project": project,
-            "agent": name,
-            "supabase_url": SUPABASE_URL,
-            "check_command": f"python3 {comms_path} check",
-            "read_command": f"python3 {comms_path} read {project} {name}",
-            "send_command": f"python3 {comms_path} send {project} {name}:{{to}} '{{message}}'",
-            "platform": os_name
-        }
-        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")
+        # Codex reads ~/.codex/config.toml globally — workspace .mcp.json is ignored.
+        # Use setup_clients.setup_global to write the proper TOML config.
+        import importlib
+        _setup_global = importlib.import_module("meshcode.setup_clients").setup_global
+        _setup_global("codex", project, name, actual_role)
 
     else:
         print(f"[meshcode] Unknown hook target: {hook_target}. Use 'claude' or 'codex'.")
@@ -1629,9 +1733,10 @@ def connect(project, name, hook_target="claude", role=""):
         print(f"  3. Start using tools: meshcode_send, meshcode_read, etc.")
         print(f"  No extra terminal. No watch loops. No AppleScript.")
     else:
-        print(f"  Read:    python3 {comms_path} read {project} {name}")
-        print(f"  Send:    python3 {comms_path} send {project} {name}:<target> '<message>'")
-        print(f"  Board:   python3 {comms_path} board {project}")
+        _py = sys.executable
+        print(f"  Read:    {_py} {comms_path} read {project} {name}")
+        print(f"  Send:    {_py} {comms_path} send {project} {name}:<target> \"<message>\"")
+        print(f"  Board:   {_py} {comms_path} board {project}")
     print()
 
 
@@ -1840,6 +1945,15 @@ Show conversation history. Optionally filter to messages between two agents.
 EXAMPLES:
   meshcode history my-app 50
   meshcode history my-app 20 backend,frontend
+""",
+    "inbox": """meshcode inbox <project> <name>
+
+All-in-one overview: agent status, unread messages, and open tasks.
+Alias: meshcode next
+
+EXAMPLES:
+  meshcode inbox my-app backend
+  meshcode next my-app frontend
 """,
     "projects": """meshcode projects
 
@@ -2050,6 +2164,7 @@ if __name__ == "__main__":
         # Supports both:
         #   send <project> <from>:<to> <message>
         #   send --project X --from Y --to Z --msg "text" [--type T]
+        #   echo '{"key":"val"}' | meshcode send <project> <from>:<to> -
         compact = bool(flags.get("compact"))
         if "from" in flags and "to" in flags:
             proj = flags.get("project", pos[0] if len(pos) > 0 else "default")
@@ -2062,6 +2177,9 @@ if __name__ == "__main__":
             proj = pos[0] if len(pos) > 0 else "default"
             target = pos[1] if len(pos) > 1 else ""
             message = " ".join(pos[2:]) if len(pos) > 2 else ""
+            # Support stdin: `meshcode send proj from:to -` reads from pipe
+            if message.strip() == "-" and not sys.stdin.isatty():
+                message = sys.stdin.read().strip()
             if ":" in target:
                 from_a, to_a = target.split(":", 1)
             else:
@@ -2092,6 +2210,11 @@ if __name__ == "__main__":
         name = flags.get("name", pos[1] if len(pos) > 1 else "agent")
         read_messages(proj, name)
 
+    elif cmd in ("inbox", "next"):
+        proj = flags.get("project", pos[0] if len(pos) > 0 else "default")
+        name = flags.get("name", pos[1] if len(pos) > 1 else "agent")
+        inbox(proj, name)
+
     elif cmd == "check":
         hook_check()
 
@@ -2427,6 +2550,7 @@ if __name__ == "__main__":
 
     elif cmd == "whoami":
         # Show the logged-in user identity from profile_meta.json
+        verbose = "--verbose" in sys.argv or "-v" in sys.argv
         meta_path = Path.home() / ".meshcode" / "profile_meta.json"
         if meta_path.exists():
             try:
@@ -2441,6 +2565,25 @@ if __name__ == "__main__":
                     print(f"  user ID:      {meta['user_id']}")
                 active = os.environ.get("MESHCODE_KEYCHAIN_PROFILE") or "default"
                 print(f"  profile:      {active}")
+
+                if verbose:
+                    # Show projects, agents, plan, API key status
+                    api_key = _load_api_key_for_cli()
+                    if api_key:
+                        print(f"  api key:      {api_key[:8]}...{api_key[-4:]}")
+                        # List projects
+                        result = sb_rpc("mc_list_user_projects", {"p_api_key": api_key})
+                        if isinstance(result, dict) and result.get("ok"):
+                            projects = result.get("projects", [])
+                            print(f"\n  Projects ({len(projects)}):")
+                            for p in projects:
+                                agent_count = p.get("agent_count", "?")
+                                plan = p.get("plan", "free")
+                                print(f"    {p.get('name', '?'):20s}  plan={plan:12s}  agents={agent_count}")
+                        else:
+                            print(f"\n  Projects: (could not fetch)")
+                    else:
+                        print(f"  api key:      not found")
                 print()
             except Exception:
                 print("[meshcode] Could not read profile. Run `meshcode login <api_key>`.")
@@ -2558,7 +2701,7 @@ if __name__ == "__main__":
 
     else:
         known_cmds = [
-            "register", "send", "broadcast", "read", "check", "watch",
+            "register", "send", "broadcast", "read", "check", "watch", "inbox", "next",
             "board", "update", "status", "projects", "list", "ls",
             "history", "clear", "unregister", "connect", "disconnect",
             "setup", "run", "go", "invite", "join", "invites", "members",

{meshcode-2.10.40 → meshcode-2.10.41}/meshcode/meshcode_mcp/backend.py

@@ -409,7 +409,43 @@ def register_agent(project: str, name: str, role: str = "", api_key: Optional[st
     }
 
 
+def resolve_agent_name(project_id: str, name: str) -> str:
+    """Resolve a partial or exact agent name to the full registered name.
+
+    Returns the exact match if found, or a unique prefix/substring match.
+    Returns the original name unchanged if no match or ambiguous.
+    Broadcast target '*' is passed through unchanged.
+    """
+    if not name or name == "*":
+        return name
+    # Exact match — fast path
+    exact = sb_select("mc_agents",
+                      f"project_id=eq.{project_id}&name=eq.{quote(name)}",
+                      limit=1)
+    if exact:
+        return name
+    # Fuzzy: prefix or substring match among registered agents
+    agents = sb_select("mc_agents", f"project_id=eq.{project_id}",
+                       columns="name")
+    if not agents:
+        return name
+    all_names = [a["name"] for a in agents]
+    # Try prefix match first
+    prefix_matches = [n for n in all_names if n.startswith(name)]
+    if len(prefix_matches) == 1:
+        return prefix_matches[0]
+    # Try substring match
+    sub_matches = [n for n in all_names if name in n]
+    if len(sub_matches) == 1:
+        return sub_matches[0]
+    # Ambiguous or no match — return original
+    return name
+
+
 def send_message(project_id: str, from_agent: str, to_agent: str, payload: Any, msg_type: str = "msg", parent_msg_id: Optional[str] = None, sensitive: bool = False, api_key: Optional[str] = None, encrypted: bool = False) -> Dict:
+    # Normalize partial agent names to full registered names
+    to_agent = resolve_agent_name(project_id, to_agent)
+
     if not isinstance(payload, dict):
         payload = {"text": str(payload)}
 
@@ -698,16 +734,19 @@ def heartbeat(project_id: str, agent: str) -> Dict:
     return result or {}
 
 
-def set_status(project_id: str, agent: str, status: str, task: str = "", api_key: Optional[str] = None) -> Dict:
+def set_status(project_id: str, agent: str, status: str, task: str = "", api_key: Optional[str] = None, editor: Optional[str] = None) -> Dict:
     # Use SECURITY DEFINER RPC when api_key is available (anon PATCH silently fails)
     if api_key:
-        rpc_result = sb_rpc("mc_agent_set_status_by_api_key", {
+        params = {
             "p_api_key": api_key,
             "p_project_id": project_id,
             "p_agent_name": agent,
             "p_status": status,
             "p_task": task,
-        })
+        }
+        if editor:
+            params["p_editor"] = editor
+        rpc_result = sb_rpc("mc_agent_set_status_by_api_key", params)
         if isinstance(rpc_result, dict) and rpc_result.get("ok"):
             return {"ok": True, "status": status}
         # Fall through to direct PATCH if RPC doesn't exist yet
@@ -716,6 +755,8 @@ def set_status(project_id: str, agent: str, status: str, task: str = "", api_key
     updates = {"status": status, "last_heartbeat": _now_iso()}
     if task:
         updates["task"] = task
+    if editor:
+        updates["editor"] = editor
     result = sb_update("mc_agents", f"project_id=eq.{project_id}&name=eq.{quote(agent)}", updates)
     if isinstance(result, dict) and result.get("_error"):
         return {"error": result["_error"]}
@@ -836,6 +877,7 @@ class MeshCodeBackend:
     ``from meshcode.meshcode_mcp.backend import MeshCodeBackend`` resolves.
     """
     get_project_id = staticmethod(get_project_id)
+    resolve_agent_name = staticmethod(resolve_agent_name)
     register_agent = staticmethod(register_agent)
     send_message = staticmethod(send_message)
     read_inbox = staticmethod(read_inbox)

{meshcode-2.10.40 → meshcode-2.10.41}/meshcode/meshcode_mcp/server.py

@@ -373,6 +373,7 @@ log = logging.getLogger("meshcode-mcp")
 PROJECT_NAME = os.environ.get("MESHCODE_PROJECT", "")
 AGENT_NAME = os.environ.get("MESHCODE_AGENT", "")
 AGENT_ROLE = os.environ.get("MESHCODE_ROLE", "")
+EDITOR_TYPE = os.environ.get("MESHCODE_EDITOR_TYPE", "")
 
 if not PROJECT_NAME or not AGENT_NAME:
     print(
@@ -488,18 +489,18 @@ except Exception:
 # 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:
+def _flip_status(status: str, task: str = "", editor: Optional[str] = None) -> bool:
     """Write status via RPC for reliable updates (anon PATCH silently fails).
 
     Falls back to direct PATCH only when no api_key is available (tests).
     """
     try:
-        result = be.set_status(_PROJECT_ID, AGENT_NAME, status, task, api_key=_get_api_key())
+        result = be.set_status(_PROJECT_ID, AGENT_NAME, status, task, api_key=_get_api_key(), editor=editor)
         return isinstance(result, dict) and result.get("ok", False)
     except Exception:
         return False
 
-if not _flip_status("idle", ""):
+if not _flip_status("idle", "", editor=EDITOR_TYPE or None):
     _mc_log(f" could not flip status to idle", "warn")
 
 
@@ -1195,8 +1196,10 @@ def _heartbeat_loop_inner():
             elif cur_state == "online" and idle_secs > 30:
                 # Brief idle — show as idle, not sleeping yet
                 _set_state("idle", "idle")
-            elif cur_state == "idle" and idle_secs > 300 and parent_cpu < 2.0 and not _STAY_AWAKE:
-                # Extended idle + no CPU activity → sleeping (5 min, not 90s)
+            elif cur_state == "idle" and idle_secs > 300 and parent_cpu < 2.0 and not _STAY_AWAKE and not in_wait:
+                # Extended idle + no CPU activity + NOT in wait loop → sleeping
+                # Never auto-sleep during meshcode_wait — the agent is actively
+                # listening for messages, not truly idle.
                 _set_state("sleeping", "sleeping")
 
             # Sync current state to DB (in case realtime missed it)
@@ -1770,12 +1773,15 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
                 pass  # All messages already seen — fall through to wait loop
             else:
                 split = _split_messages(deduped)
-                return {
-                    "refused": True,
-                    "reason": f"You have {len(deduped)} unread messages. Process them before waiting.",
-                    "got_message": True,
-                    **split,
-                }
+                # Only refuse for real messages — ack-only batches should not block wait
+                if split["messages"] or split["done_signals"]:
+                    return {
+                        "refused": True,
+                        "reason": f"You have {split['count']} unread messages. Process them before waiting.",
+                        "got_message": True,
+                        **split,
+                    }
+                # Ack-only batch — fall through to wait loop
     except Exception:
         pass
 
@@ -3123,7 +3129,12 @@ def _auto_update() -> None:
     print(f"[meshcode] Updated to {latest}, restarting...", file=sys.stderr)
     os.environ["MESHCODE_UPDATED"] = "1"
     try:
-        os.execv(sys.executable, [sys.executable] + sys.argv)
+        if sys.platform == "win32":
+            import subprocess as _sp_reexec
+            _sp_reexec.Popen([sys.executable] + sys.argv)
+            sys.exit(0)
+        else:
+            os.execv(sys.executable, [sys.executable] + sys.argv)
     except Exception as e:
         log.debug(f"[meshcode] Re-exec failed: {e}, continuing with old version")
 

{meshcode-2.10.40 → meshcode-2.10.41}/meshcode/run_agent.py

@@ -531,6 +531,9 @@ def run(agent: str, project: Optional[str] = None, editor_override: Optional[str
     print(f"[meshcode]   Closing the editor will flip this agent offline.")
     print()
 
+    # Set editor type so MCP server can report it to the dashboard
+    os.environ["MESHCODE_EDITOR_TYPE"] = editor
+
     if editor == "claude":
         # Claude Code: run from inside the workspace and let Claude Code
         # auto-discover .mcp.json as a PROJECT-scoped MCP. We used to pass

{meshcode-2.10.40 → meshcode-2.10.41}/meshcode/setup_clients.py

@@ -158,7 +158,8 @@ def _suggest_projects(api_key: str, sb: dict):
 
 def _build_server_block(project: str, project_id: str, agent: str, role: str,
                          api_key: str, sb: Dict[str, str],
-                         keychain_profile: str = "default") -> Dict[str, Any]:
+                         keychain_profile: str = "default",
+                         editor_type: str = "") -> Dict[str, Any]:
     """Build the MCP server config block for an agent.
 
     1.4.1+ does NOT bake the api key into the env. Instead it bakes a
@@ -184,6 +185,8 @@ def _build_server_block(project: str, project_id: str, agent: str, role: str,
         # parts of the package (e.g. self_update) skip auto-update inside it.
         "MESHCODE_MCP_SERVE": "1",
     }
+    if editor_type:
+        env["MESHCODE_EDITOR_TYPE"] = editor_type
     # Belt-and-suspenders fallback: if the OS doesn't have a keychain backend
     # the MCP server can't read the key from there, so we still need to pass
     # it via env. Probe and only include it as a fallback path.

{meshcode-2.10.40 → meshcode-2.10.41}/meshcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.10.40
+Version: 2.10.41
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT
@@ -400,10 +400,32 @@ meshcode projects                       # lists all your meshworks
 **8. Unknown command (e.g., `meshcode list`)**
 Since v2.0.2, the CLI suggests the closest match instead of dumping the full help text. Common aliases: `list` and `ls` both work for `projects`.
 
-**5. `MCP server failed to start` in the Claude Code `/mcp` panel**
+**9. Windows: agent registers but never appears online**
+On Windows, especially with Python 3.14+, you may see `ImportError` crashes or agents that register but stay offline. This was fixed in v2.10.40. Upgrade first:
+```bash
+pip install meshcode --upgrade
+```
+If the agent still fails after upgrading, check that your `.mcp.json` command path is valid. On Windows, the MCP config should use `python` (not `python3`, which doesn't exist on Windows):
+```json
+{
+  "command": "python",
+  "args": ["-m", "meshcode_mcp", "serve"]
+}
+```
+If `meshcode setup` was run from a conda/venv environment that no longer exists, the baked path in `.mcp.json` will be stale. Re-run `meshcode setup <project> <agent>` from your current Python environment to fix it.
+
+As a fast-path workaround, you can set `MESHCODE_PROJECT_ID` as an environment variable to bypass the project name lookup at boot (which can fail on Windows due to RLS visibility):
+```bash
+set MESHCODE_PROJECT_ID=your-project-uuid   # Windows cmd
+$env:MESHCODE_PROJECT_ID="your-project-uuid"  # Windows PowerShell
+```
+
+You can also run `meshcode doctor` (v2.10.41+) to diagnose stale paths, missing dependencies, and config issues across all your workspaces.
+
+**10. `MCP server failed to start` in the Claude Code `/mcp` panel**
 Run `claude --debug` to see the underlying error. Nine times out of ten it's a stale or missing key — run `meshcode login mc_xxx` again.
 
-**6. PyPI says `Could not find version 1.x.x` immediately after a publish**
+**11. PyPI says `Could not find version 1.x.x` immediately after a publish**
 CDN propagation. Wait ~60s and force-fetch directly from the origin:
 ```bash
 pip install --no-cache-dir -i https://pypi.org/simple/ meshcode

{meshcode-2.10.40 → meshcode-2.10.41}/pyproject.toml

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